Cleanup use of deprecated constructs

Continue cleaning up of deprecated warnings, so that we get a stable
baseline before embarking on major work items in Aluminium.

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

diff --git a/netconf/netconf-console/src/main/java/org/opendaylight/netconf/console/impl/NetconfCommandsImpl.java b/netconf/netconf-console/src/main/java/org/opendaylight/netconf/console/impl/NetconfCommandsImpl.java
index fbe5c9874af8eb00490d23730f71e94e3d8300fa..bc6c527a8501cbe89a7d5e9f53992614c505debe 100644 (file)
--- a/netconf/netconf-console/src/main/java/org/opendaylight/netconf/console/impl/NetconfCommandsImpl.java
+++ b/netconf/netconf-console/src/main/java/org/opendaylight/netconf/console/impl/NetconfCommandsImpl.java
@@ -36,7 +36,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev15
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.Credentials;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.credentials.LoginPasswordBuilder;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
@@ -156,7 +155,7 @@ public class NetconfCommandsImpl implements NetconfCommands {
         final Node node = new NodeBuilder()
                 .withKey(new NodeKey(nodeId))
                 .setNodeId(nodeId)
-                .addAugmentation(NetconfNode.class, netconfNode)
+                .addAugmentation(netconfNode)
                 .build();
 
         final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
@@ -221,20 +220,19 @@ public class NetconfCommandsImpl implements NetconfCommands {
             final String newPassword = Strings.isNullOrEmpty(updated.get(NetconfConsoleConstants.PASSWORD))
                     ? updated.get(NetconfConsoleConstants.PASSWORD) : password;
 
-            final Credentials credentials =
-                    new LoginPasswordBuilder().setPassword(newPassword).setUsername(newUsername).build();
-            final NetconfNode updatedNetconfNode = new NetconfNodeBuilder()
-                    .setHost(new Host(new IpAddress(new Ipv4Address(deviceIp))))
-                    .setPort(new PortNumber(Uint16.valueOf(Integer.decode(devicePort))))
-                    .setTcpOnly(tcpOnly)
-                    .setSchemaless(isSchemaless)
-                    .setCredentials(credentials)
-                    .build();
-
             final Node updatedNode = new NodeBuilder()
                     .withKey(node.key())
                     .setNodeId(node.getNodeId())
-                    .addAugmentation(NetconfNode.class, updatedNetconfNode)
+                    .addAugmentation(new NetconfNodeBuilder()
+                        .setHost(new Host(new IpAddress(new Ipv4Address(deviceIp))))
+                        .setPort(new PortNumber(Uint16.valueOf(Integer.decode(devicePort))))
+                        .setTcpOnly(tcpOnly)
+                        .setSchemaless(isSchemaless)
+                        .setCredentials(new LoginPasswordBuilder()
+                            .setPassword(newPassword)
+                            .setUsername(newUsername)
+                            .build())
+                        .build())
                     .build();
 
             final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();

diff --git a/netconf/netconf-console/src/test/java/org/opendaylight/netconf/console/impl/NetconfCommandsImplTest.java b/netconf/netconf-console/src/test/java/org/opendaylight/netconf/console/impl/NetconfCommandsImplTest.java
index 42596c299cddfda2c263feb1a5ba99098f0e6450..28b8eff6087b2fd638205cc285ec5496e815c61b 100644 (file)
--- a/netconf/netconf-console/src/test/java/org/opendaylight/netconf/console/impl/NetconfCommandsImplTest.java
+++ b/netconf/netconf-console/src/test/java/org/opendaylight/netconf/console/impl/NetconfCommandsImplTest.java
@@ -241,15 +241,14 @@ public class NetconfCommandsImplTest {
         final AvailableCapabilities avCaps =
                 new AvailableCapabilitiesBuilder().setAvailableCapability(avCapList).build();
 
-        final NetconfNode nn = new NetconfNodeBuilder().setConnectionStatus(cs).setHost(host).setPort(port)
-                .setAvailableCapabilities(avCaps).build();
         final NodeId nodeId = new NodeId(nodeIdent);
         final NodeKey nk = new NodeKey(nodeId);
-        final NodeBuilder nb = new NodeBuilder();
-        nb.withKey(nk);
-        nb.setNodeId(nodeId);
-        nb.addAugmentation(NetconfNode.class, nn);
-        return nb.build();
+        return new NodeBuilder()
+                .withKey(nk)
+                .setNodeId(nodeId)
+                .addAugmentation(new NetconfNodeBuilder()
+                    .setConnectionStatus(cs).setHost(host).setPort(port).setAvailableCapabilities(avCaps).build())
+                .build();
     }
 
     private static void assertBaseNodeAttributes(final Map<?, ?> mapNode) {

diff --git a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java
index 8994b7f4421a89c84060d848b8d65a6e74007ee5..af2d78bd27c83c6d56089b2e3601c6b584fde942 100644 (file)
--- a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java
+++ b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java
@@ -50,7 +50,6 @@ import org.opendaylight.netconf.sal.connect.netconf.sal.KeepaliveSalFacade.Keepa
 import org.opendaylight.netconf.sal.connect.netconf.sal.SchemalessNetconfDeviceRpc;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.get.config.input.source.ConfigSource;
-import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
 import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
 import org.opendaylight.yangtools.yang.common.Empty;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -63,7 +62,6 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 
 /**
  * Provides base operations for netconf e.g. get, get-config, edit-config, (un)lock, commit etc.
@@ -77,11 +75,6 @@ public final class NetconfBaseOps {
     private final MountPointContext mountContext;
     private final RpcStructureTransformer transformer;
 
-    @Deprecated
-    public NetconfBaseOps(final DOMRpcService rpc, final EffectiveModelContext schemaContext) {
-        this(rpc, new EmptyMountPointContext(schemaContext));
-    }
-
     public NetconfBaseOps(final DOMRpcService rpc, final MountPointContext mountContext) {
         this.rpc = rpc;
         this.mountContext = mountContext;

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java
index 31789e96a3c18edd01ae51b2f459ddd20813da95..80aa6c4de14727ccdb4a21d0c889a9eca969cca4 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java
@@ -41,6 +41,7 @@ import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
@@ -49,7 +50,6 @@ import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
 @RunWith(MockitoJUnitRunner.StrictStubs.class)
@@ -76,7 +76,7 @@ public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
 
     @Test
     public void testIgnoreNonVisibleData() {
-        final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(EffectiveModelContext.class)),
+        final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(MountPointContext.class)),
                 false);
         final MapNode emptyList = ImmutableNodes.mapNodeBuilder(NETCONF_FILTER_QNAME).build();
         tx.merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier
@@ -92,7 +92,7 @@ public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
                 .when(rpc).invokeRpc(any(SchemaPath.class), isNull());
 
-        final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(EffectiveModelContext.class)),
+        final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(MountPointContext.class)),
                 false);
         try {
             tx.commit().get();
@@ -121,7 +121,7 @@ public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
                 .doReturn(rpcErrorFuture).when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
 
-        final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(EffectiveModelContext.class)),
+        final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(MountPointContext.class)),
                 false);
 
         try {
@@ -139,7 +139,7 @@ public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
                 .when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
 
         final WriteRunningTx tx = new WriteRunningTx(id,
-            new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchemaWithNotifications().getEffectiveModelContext()), false);
+            new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchemaWithNotifications().getMountPointContext()), false);
 
         tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
         tx.commit();
@@ -158,7 +158,7 @@ public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
                 .when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
         final WriteCandidateTx tx = new WriteCandidateTx(
-                id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getEffectiveModelContext()), false);
+                id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getMountPointContext()), false);
         final TxListener listener = mock(TxListener.class);
         tx.addListener(listener);
         tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
@@ -174,7 +174,7 @@ public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
                 .when(rpc).invokeRpc(any(SchemaPath.class), isNull());
         final WriteCandidateTx tx = new WriteCandidateTx(
-                id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getEffectiveModelContext()), false);
+                id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getMountPointContext()), false);
         final TxListener listener = mock(TxListener.class);
         tx.addListener(listener);
         tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
@@ -191,7 +191,7 @@ public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
         doReturn(FluentFutures.immediateFailedFluentFuture(cause))
                 .when(rpc).invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
         final WriteCandidateTx tx = new WriteCandidateTx(
-                id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getEffectiveModelContext()), false);
+                id, new NetconfBaseOps(rpc, BASE_SCHEMAS.getBaseSchema().getMountPointContext()), false);
         final TxListener listener = mock(TxListener.class);
         tx.addListener(listener);
         tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTxTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTxTest.java
index f0de12008823482b29adc9f201ec5f47c4356e2e..69cd7061d7440b99c82be51c8cf06b04158924f9 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTxTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/ReadOnlyTxTest.java
@@ -16,26 +16,25 @@ import java.net.InetSocketAddress;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class ReadOnlyTxTest {
-
-    private static final YangInstanceIdentifier PATH = YangInstanceIdentifier.create();
-
     @Mock
     private DOMRpcService rpc;
     @Mock
@@ -43,45 +42,43 @@ public class ReadOnlyTxTest {
 
     @Before
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(mockedNode))).when(rpc)
                 .invokeRpc(any(SchemaPath.class), any(ContainerNode.class));
-        doReturn("node").when(mockedNode).toString();
     }
 
     @Test
     public void testRead() throws Exception {
-        final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(EffectiveModelContext.class));
+        final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(MountPointContext.class));
 
         final ReadOnlyTx readOnlyTx =
                 new ReadOnlyTx(netconfOps, new RemoteDeviceId("a", new InetSocketAddress("localhost", 196)));
 
-        readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create());
+        readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
         verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
                 NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME)), any(ContainerNode.class));
-        readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, PATH);
+        readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
         verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
                 NetconfMessageTransformUtil.NETCONF_GET_QNAME)), any(ContainerNode.class));
     }
 
     @Test
     public void testExists() throws Exception {
-        final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(EffectiveModelContext.class));
+        final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(MountPointContext.class));
 
         final ReadOnlyTx readOnlyTx =
                 new ReadOnlyTx(netconfOps, new RemoteDeviceId("a", new InetSocketAddress("localhost", 196)));
 
-        readOnlyTx.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create());
+        readOnlyTx.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
         verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
                 NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME)), any(ContainerNode.class));
-        readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, PATH);
+        readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
         verify(rpc).invokeRpc(Mockito.eq(NetconfMessageTransformUtil.toPath(
                 NetconfMessageTransformUtil.NETCONF_GET_QNAME)), any(ContainerNode.class));
     }
 
     @Test
     public void testIdentifier() throws Exception {
-        final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(EffectiveModelContext.class));
+        final NetconfBaseOps netconfOps = new NetconfBaseOps(rpc, mock(MountPointContext.class));
         final ReadOnlyTx tx1 =
                 new ReadOnlyTx(netconfOps, new RemoteDeviceId("a", new InetSocketAddress("localhost", 196)));
         final ReadOnlyTx tx2 =

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateRunningTxTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateRunningTxTest.java
index 4974ce9ccf148933414f961bb06e9a3185cbd7f1..aabaf2edcc740ee9522bc354914b637d6bc1063c 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateRunningTxTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateRunningTxTest.java
@@ -20,8 +20,9 @@ import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTr
 import java.net.InetSocketAddress;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
@@ -30,6 +31,7 @@ import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.common.Empty;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -39,6 +41,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class WriteCandidateRunningTxTest extends AbstractTestModelTest {
     @Mock
     private DOMRpcService rpc;
@@ -46,10 +49,9 @@ public class WriteCandidateRunningTxTest extends AbstractTestModelTest {
     private RemoteDeviceId id;
 
     @Before
-    public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
+    public void setUp() {
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult())).when(rpc).invokeRpc(any(), any());
-        netconfOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+        netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
         id = new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("0.0.0.0", 17830));
     }
 

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateTxTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateTxTest.java
index 59e140b67ae93b1680d1f4172c58dac63066fe22..a18a922dd71cf748f31b87f88ea035d10ee54484 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateTxTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteCandidateTxTest.java
@@ -16,8 +16,9 @@ import static org.mockito.Mockito.verify;
 import java.net.InetSocketAddress;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
@@ -25,9 +26,11 @@ import org.opendaylight.netconf.sal.connect.netconf.AbstractTestModelTest;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class WriteCandidateTxTest extends AbstractTestModelTest {
     @Mock
     private DOMRpcService rpc;
@@ -35,10 +38,9 @@ public class WriteCandidateTxTest extends AbstractTestModelTest {
     private RemoteDeviceId id;
 
     @Before
-    public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
+    public void setUp() {
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult())).when(rpc).invokeRpc(any(), any());
-        netconfOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+        netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
         id = new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("0.0.0.0", 17830));
     }
 
@@ -59,5 +61,4 @@ public class WriteCandidateTxTest extends AbstractTestModelTest {
                 NetconfMessageTransformUtil.COMMIT_RPC_CONTENT);
         verify(rpc).invokeRpc(eq(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_UNLOCK_QNAME)), any());
     }
-
 }
\ No newline at end of file

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteRunningTxTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteRunningTxTest.java
index cd672a773e50841dcb5cdf4a77ef05b8bd844c97..5b492ba1b54140ff0c00118190dc17ffdc870623 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteRunningTxTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/sal/tx/WriteRunningTxTest.java
@@ -17,8 +17,9 @@ import static org.mockito.Mockito.verify;
 import java.net.InetSocketAddress;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
@@ -26,9 +27,11 @@ import org.opendaylight.netconf.sal.connect.netconf.AbstractTestModelTest;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class WriteRunningTxTest extends AbstractTestModelTest {
     @Mock
     private DOMRpcService rpc;
@@ -37,9 +40,8 @@ public class WriteRunningTxTest extends AbstractTestModelTest {
 
     @Before
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
         doReturn(FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult())).when(rpc).invokeRpc(any(), any());
-        netconfOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+        netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
         id = new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("0.0.0.0", 17830));
     }
 

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/YangLibrarySchemaYangSourceProviderTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/YangLibrarySchemaYangSourceProviderTest.java
index bc94ff2f9ec55f539fdaafb77d26284d8a196ce5..1634c1db44867420540cf1e744eb95c61b1ab1d3 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/YangLibrarySchemaYangSourceProviderTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/YangLibrarySchemaYangSourceProviderTest.java
@@ -7,20 +7,20 @@
  */
 package org.opendaylight.netconf.sal.connect.netconf.schema;
 
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertThrows;
 
-import com.google.common.io.ByteStreams;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.net.InetSocketAddress;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.Collections;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
@@ -30,7 +30,6 @@ import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
 import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
 
 public class YangLibrarySchemaYangSourceProviderTest {
-
     private SourceIdentifier workingSid;
     private YangLibrarySchemaYangSourceProvider yangLibrarySchemaYangSourceProvider;
 
@@ -47,8 +46,9 @@ public class YangLibrarySchemaYangSourceProviderTest {
     public void testGetSource() throws Exception {
         ListenableFuture<? extends YangTextSchemaSource> source = yangLibrarySchemaYangSourceProvider
                 .getSource(workingSid);
-        final String x = new String(ByteStreams.toByteArray(source.get().openStream()));
-        Assert.assertThat(x, CoreMatchers.containsString("module config-test-rpc"));
+
+        final String x = source.get().asCharSource(StandardCharsets.UTF_8).read();
+        assertThat(x, containsString("module config-test-rpc"));
     }
 
     @Test
@@ -59,17 +59,14 @@ public class YangLibrarySchemaYangSourceProviderTest {
         final YangLibrarySchemaYangSourceProvider failingYangLibrarySchemaYangSourceProvider =
                 new YangLibrarySchemaYangSourceProvider(id, sourceIdentifierURLMap);
 
-        try {
-            failingYangLibrarySchemaYangSourceProvider.getSource(workingSid).get();
-            fail();
-        } catch (ExecutionException e) {
-            final Throwable cause = e.getCause();
-            assertTrue(cause instanceof SchemaSourceException);
-        }
+        final ListenableFuture<?> future = failingYangLibrarySchemaYangSourceProvider.getSource(workingSid);
+        final ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+        assertThat(ex.getCause(), instanceOf(SchemaSourceException.class));
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testGetSourceNotAvailable() throws Exception {
-        yangLibrarySchemaYangSourceProvider.getSource(RevisionSourceIdentifier.create("aaaaa"));
+        assertThrows(IllegalArgumentException.class,
+            () -> yangLibrarySchemaYangSourceProvider.getSource(RevisionSourceIdentifier.create("aaaaa")));
     }
 }

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformerTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformerTest.java
index 0c13249f5323d961f82c0e1430b7585b50bc1653..b9079fed047aa9b56197042b57dddb0ac4053c6b 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformerTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformerTest.java
@@ -671,7 +671,7 @@ public class NetconfMessageTransformerTest extends AbstractBaseSchemasTest {
     public void toActionRequestConflictingInListTest() {
         QName barInputQname = QName.create(BAR_QNAME, "bar");
         QName barIdQname = QName.create(BAR_QNAME, "bar-id");
-        Byte barInput = new Byte("1");
+        Byte barInput = 1;
 
         List<PathArgument> nodeIdentifiers = new ArrayList<>();
         nodeIdentifiers.add(NodeIdentifier.create(BAR_QNAME));

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOpsTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOpsTest.java
index 83f1912cc00cd9ea2b4137170b97b1c48b970068..1b015aaa6195f3933114fb7a256457c82b89987e 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOpsTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOpsTest.java
@@ -24,9 +24,10 @@ import org.custommonkey.xmlunit.XMLUnit;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.ArgumentMatcher;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.netconf.api.ModifyAction;
 import org.opendaylight.netconf.api.NetconfMessage;
@@ -51,6 +52,7 @@ import org.w3c.dom.Element;
 import org.w3c.dom.NamedNodeMap;
 import org.xml.sax.SAXException;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class NetconfBaseOpsTest extends AbstractTestModelTest {
     private static final QName CONTAINER_Q_NAME = QName.create("test:namespace", "2013-07-22", "c");
 
@@ -66,7 +68,6 @@ public class NetconfBaseOpsTest extends AbstractTestModelTest {
 
     @Before
     public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
         final InputStream okStream = getClass().getResourceAsStream("/netconfMessages/rpc-reply_ok.xml");
         final InputStream dataStream = getClass().getResourceAsStream("/netconfMessages/rpc-reply_get.xml");
         final NetconfMessage ok = new NetconfMessage(XmlUtil.readXmlToDocument(okStream));
@@ -95,7 +96,7 @@ public class NetconfBaseOpsTest extends AbstractTestModelTest {
         final RemoteDeviceId id =
                 new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830));
         callback = new NetconfRpcFutureCallback("prefix", id);
-        baseOps = new NetconfBaseOps(rpc, SCHEMA_CONTEXT);
+        baseOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
     }
 
     @Test

diff --git a/netconf/yanglib/src/test/java/org/opendaylight/yanglib/impl/YangLibProviderTest.java b/netconf/yanglib/src/test/java/org/opendaylight/yanglib/impl/YangLibProviderTest.java
index 7fe78602dafd5b7fdbe45069f69f8ab65fe38486..f47a74a2b2f41ced3885fe050863de3d67b643e3 100644 (file)
--- a/netconf/yanglib/src/test/java/org/opendaylight/yanglib/impl/YangLibProviderTest.java
+++ b/netconf/yanglib/src/test/java/org/opendaylight/yanglib/impl/YangLibProviderTest.java
@@ -14,7 +14,7 @@ import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
 
@@ -30,9 +30,10 @@ import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.WriteTransaction;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
@@ -57,6 +58,7 @@ import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
 import org.opendaylight.yangtools.yang.parser.impl.YangParserFactoryImpl;
 import org.opendaylight.yangtools.yang.parser.rfc7950.repo.ASTSchemaSource;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class YangLibProviderTest {
     private static final File CACHE_DIR = new File("target/yanglib");
 
@@ -82,8 +84,6 @@ public class YangLibProviderTest {
 
     @Before
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
-
         try {
             if (CACHE_DIR.exists()) {
                 FileUtils.cleanDirectory(CACHE_DIR);
@@ -152,7 +152,7 @@ public class YangLibProviderTest {
         List<PotentialSchemaSource<?>> potentialSources = Collections.emptyList();
         yangLibProvider.schemaSourceRegistered(potentialSources);
 
-        verifyZeroInteractions(dataBroker, writeTransaction);
+        verifyNoMoreInteractions(dataBroker, writeTransaction);
 
         // test list of non yang schema sources registered
         // expected behavior is to do nothing
@@ -168,7 +168,7 @@ public class YangLibProviderTest {
                         ASTSchemaSource.class, PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
 
         yangLibProvider.schemaSourceRegistered(potentialSources);
-        verifyZeroInteractions(dataBroker, writeTransaction);
+        verifyNoMoreInteractions(dataBroker, writeTransaction);
 
         // add yang schema source to list
         potentialSources.add(
@@ -200,7 +200,7 @@ public class YangLibProviderTest {
         yangLibProvider.schemaSourceUnregistered(nonYangSource);
 
         // expected behaviour is to do nothing if non yang based source is unregistered
-        verifyZeroInteractions(dataBroker, writeTransaction);
+        verifyNoMoreInteractions(dataBroker, writeTransaction);
     }
 
     @Test

diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/DOMMountPointServiceHandler.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/DOMMountPointServiceHandler.java
index 501aeafa736970014476257f713d509c9b2732cc..6a89d29b9949e96e1f1acf098dededa34b5506d7 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/DOMMountPointServiceHandler.java
+++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/DOMMountPointServiceHandler.java
@@ -16,7 +16,6 @@ import org.opendaylight.mdsal.dom.api.DOMMountPointService;
 
 /**
  * Implementation of {@link DOMMountPointServiceHandler}.
- *
  */
 @Singleton
 public final class DOMMountPointServiceHandler implements Handler<DOMMountPointService> {
@@ -33,11 +32,6 @@ public final class DOMMountPointServiceHandler implements Handler<DOMMountPointS
         this.domMountPointService = requireNonNull(domMountPointService);
     }
 
-    @Deprecated
-    public static DOMMountPointServiceHandler newInstance(final DOMMountPointService domMountPointService) {
-        return new DOMMountPointServiceHandler(domMountPointService);
-    }
-
     @Override
     public DOMMountPointService get() {
         return this.domMountPointService;

diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/SchemaContextHandler.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/SchemaContextHandler.java
index c40bf84c5741673fd5600d3116f48f36e08ccdf9..daeb0c1443e1329748fee3d739dd4ba753770352 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/SchemaContextHandler.java
+++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/handlers/SchemaContextHandler.java
@@ -68,12 +68,6 @@ public class SchemaContextHandler implements SchemaContextListenerHandler, AutoC
         this.domSchemaService = domSchemaService;
     }
 
-    @Deprecated
-    public static SchemaContextHandler newInstance(final TransactionChainHandler transactionChainHandler,
-            final DOMSchemaService domSchemaService) {
-        return new SchemaContextHandler(transactionChainHandler, domSchemaService);
-    }
-
     @PostConstruct
     public void init() {
         listenerRegistration = domSchemaService.registerSchemaContextListener(this);

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/TestUtils.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/TestUtils.java
index 10455b5f32500dcd8ab149d6bcea0299e75eff82..86ba28be75addd19314f2871e31b6c81e9d8f8c2 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/TestUtils.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/TestUtils.java
@@ -282,7 +282,7 @@ public final class TestUtils {
         doReturn(mockTx).when(mockChain).newWriteOnlyTransaction();
 
         doReturn(mockChain).when(mockDataBroker).createTransactionChain(any());
-        SchemaContextHandler schemaContextHandler = SchemaContextHandler.newInstance(
+        SchemaContextHandler schemaContextHandler = new SchemaContextHandler(
                 new TransactionChainHandler(mockDataBroker), Mockito.mock(DOMSchemaService.class));
         schemaContextHandler.onModelContextUpdated(schemaContext);
         return schemaContextHandler;

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/test/AbstractBodyReaderTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/test/AbstractBodyReaderTest.java
index 31b7e7c323a9c473ce7a387c77f1d49b3d0bd131..b08e74378c74662320c14df6d9d4cbc9f062d786 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/test/AbstractBodyReaderTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/test/AbstractBodyReaderTest.java
@@ -52,7 +52,7 @@ public abstract class AbstractBodyReaderTest {
         doReturn(schemaContext).when(mountPoint).getEffectiveModelContext();
         doCallRealMethod().when(mountPoint).getSchemaContext();
 
-        mountPointServiceHandler = DOMMountPointServiceHandler.newInstance(mountPointService);
+        mountPointServiceHandler = new DOMMountPointServiceHandler(mountPointService);
     }
 
     protected abstract MediaType getMediaType();
@@ -62,7 +62,7 @@ public abstract class AbstractBodyReaderTest {
         return TestRestconfUtils.loadSchemaContext(yangPath, schemaContext);
     }
 
-    protected static <T extends AbstractIdentifierAwareJaxRsProvider> void mockBodyReader(
+    protected static <T extends AbstractIdentifierAwareJaxRsProvider<?>> void mockBodyReader(
             final String identifier, final T normalizedNodeProvider,
             final boolean isPost) throws NoSuchFieldException,
             SecurityException, IllegalArgumentException, IllegalAccessException {

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/JSONRestconfServiceRfc8040ImplTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/JSONRestconfServiceRfc8040ImplTest.java
index c1c6f2cc8e4e58bdb211aa5fa72e40d130f76c29..48990d363b8eaf2741582fa03da50094eadbafaf 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/JSONRestconfServiceRfc8040ImplTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/JSONRestconfServiceRfc8040ImplTest.java
@@ -8,10 +8,10 @@
 package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
 
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
@@ -192,7 +192,7 @@ public class JSONRestconfServiceRfc8040ImplTest {
         final TransactionChainHandler txChainHandler = new TransactionChainHandler(mockDOMDataBroker);
 
         final DOMMountPointServiceHandler mountPointServiceHandler =
-                DOMMountPointServiceHandler.newInstance(mockMountPointService);
+                new DOMMountPointServiceHandler(mockMountPointService);
 
         final DOMNotificationService mockNotificationService = mock(DOMNotificationService.class);
         final ServicesWrapper servicesWrapper = ServicesWrapper.newInstance(schemaContextHandler,
@@ -587,8 +587,7 @@ public class JSONRestconfServiceRfc8040ImplTest {
 
         doReturn(Optional.of(mockDOMDataBroker)).when(mockMountPoint).getService(DOMDataBroker.class);
 
-        doReturn(Optional.of(mockMountPoint))
-                .when(mockMountPointService).getMountPoint(notNull(YangInstanceIdentifier.class));
+        doReturn(Optional.of(mockMountPoint)).when(mockMountPointService).getMountPoint(notNull());
 
         return mockMountPoint;
     }

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java
index ad79f89f2a17274e7f111ac325cbd43c226c8033..23ce6437dccb46f6342b62912f952c39dce54f85 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java
@@ -197,12 +197,12 @@ public class RestconfDataServiceImplTest {
 
         transactionChainHandler = new TransactionChainHandler(mockDataBroker);
 
-        final SchemaContextHandler schemaContextHandler = SchemaContextHandler.newInstance(transactionChainHandler,
+        final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(transactionChainHandler,
                 Mockito.mock(DOMSchemaService.class));
 
         schemaContextHandler.onModelContextUpdated(this.contextRef.get());
         this.dataService = new RestconfDataServiceImpl(schemaContextHandler, this.transactionChainHandler,
-                DOMMountPointServiceHandler.newInstance(mountPointService), this.delegRestconfSubscrService,
+                new DOMMountPointServiceHandler(mountPointService), this.delegRestconfSubscrService,
                 this.actionServiceHandler);
         doReturn(Optional.of(this.mountPoint)).when(this.mountPointService)
                 .getMountPoint(any(YangInstanceIdentifier.class));

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java
index 57e8017970c926f14bbdc08b851b6c387c78314f..0d792e6479e972621e438bb9aab2070cd5c703ca 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java
@@ -66,7 +66,7 @@ public class RestconfInvokeOperationsServiceImplTest {
         final DOMDataTreeWriteTransaction wTx = mock(DOMDataTreeWriteTransaction.class);
         when(domTx.newWriteOnlyTransaction()).thenReturn(wTx);
         doReturn(CommitInfo.emptyFluentFuture()).when(wTx).commit();
-        final SchemaContextHandler schemaContextHandler = SchemaContextHandler.newInstance(txHandler,
+        final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(txHandler,
             mock(DOMSchemaService.class));
         schemaContextHandler.onModelContextUpdated(contextRef.get());
         this.invokeOperationsService =

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImplTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImplTest.java
index f535851fd5e6dc65bb71a7baa0c4cdb33484391e..bdea386052eb440effdda12841ae3dfb8dfbaf52 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImplTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImplTest.java
@@ -93,7 +93,7 @@ public class RestconfStreamsSubscriptionServiceImplTest {
         doReturn(domTx).when(dataBroker).createTransactionChain(any());
 
         transactionHandler = new TransactionChainHandler(dataBroker);
-        schemaHandler = SchemaContextHandler.newInstance(transactionHandler, mock(DOMSchemaService.class));
+        schemaHandler = new SchemaContextHandler(transactionHandler, mock(DOMSchemaService.class));
 
         DOMDataTreeChangeService dataTreeChangeService = mock(DOMDataTreeChangeService.class);
         doReturn(mock(ListenerRegistration.class)).when(dataTreeChangeService)

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/RestconfOperationsServiceTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/RestconfOperationsServiceTest.java
index c971a2761a4b83ddba56d47a83983e625e180bac..87b0a3617cc9d44fdccdde9f2cd990868d0159d8 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/RestconfOperationsServiceTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/RestconfOperationsServiceTest.java
@@ -16,8 +16,9 @@ import java.util.Set;
 import javax.ws.rs.core.UriInfo;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
 import org.opendaylight.restconf.common.context.NormalizedNodeContext;
 import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
@@ -33,6 +34,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class RestconfOperationsServiceTest {
 
     @Mock
@@ -49,11 +51,10 @@ public class RestconfOperationsServiceTest {
 
     @Before
     public void init() throws Exception {
-        MockitoAnnotations.initMocks(this);
         this.schemaContext = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/modules"));
         this.schemaContextHandler = TestUtils.newSchemaContextHandler(schemaContext);
 
-        this.domMountPointServiceHandler = DOMMountPointServiceHandler.newInstance(this.domMountPointService);
+        this.domMountPointServiceHandler = new DOMMountPointServiceHandler(this.domMountPointService);
 
         final QNameModule module1 = QNameModule.create(URI.create("module:1"));
         final QNameModule module2 = QNameModule.create(URI.create("module:2"));

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/listeners/ListenerAdapterTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/listeners/ListenerAdapterTest.java
index 84b9ef19e33133af496d4990d395500b92647e51..6822850449311a2b90d03e2e1b8376e9c6ffa68f 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/listeners/ListenerAdapterTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/listeners/ListenerAdapterTest.java
@@ -85,8 +85,7 @@ public class ListenerAdapterTest extends AbstractConcurrentDataBrokerTest {
         domDataBroker = getDomBroker();
 
         transactionChainHandler = new TransactionChainHandler(domDataBroker);
-        schemaContextHandler = SchemaContextHandler.newInstance(transactionChainHandler,
-                Mockito.mock(DOMSchemaService.class));
+        schemaContextHandler = new SchemaContextHandler(transactionChainHandler, Mockito.mock(DOMSchemaService.class));
         schemaContextHandler.onModelContextUpdated(SCHEMA_CONTEXT);
     }
 

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/websockets/WebSocketSessionHandlerTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/websockets/WebSocketSessionHandlerTest.java
index e12b1bb4dea349e70558e1fd8ffa1e6f387c58e0..30855cdaf93bbdb1185c1a416357ca5f2b83c3e1 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/websockets/WebSocketSessionHandlerTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/streams/websockets/WebSocketSessionHandlerTest.java
@@ -5,9 +5,21 @@
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-
 package org.opendaylight.restconf.nb.rfc8040.streams.websockets;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
 import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.ScheduledExecutorService;
@@ -15,10 +27,8 @@ import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import org.eclipse.jetty.websocket.api.RemoteEndpoint;
 import org.eclipse.jetty.websocket.api.Session;
-import org.junit.Assert;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
 import org.opendaylight.restconf.nb.rfc8040.streams.listeners.BaseListenerInterface;
 
 public class WebSocketSessionHandlerTest {
@@ -32,16 +42,15 @@ public class WebSocketSessionHandlerTest {
         private final ScheduledFuture pingFuture;
 
         private WebSocketTestSessionState(final int maxFragmentSize, final int heartbeatInterval) {
-            listener = Mockito.mock(BaseListenerInterface.class);
-            executorService = Mockito.mock(ScheduledExecutorService.class);
+            listener = mock(BaseListenerInterface.class);
+            executorService = mock(ScheduledExecutorService.class);
             this.heartbeatInterval = heartbeatInterval;
             this.maxFragmentSize = maxFragmentSize;
             webSocketSessionHandler = new WebSocketSessionHandler(executorService, listener, maxFragmentSize,
                     heartbeatInterval);
-            pingFuture = Mockito.mock(ScheduledFuture.class);
-            Mockito.when(executorService.scheduleWithFixedDelay(Mockito.any(Runnable.class),
-                    Mockito.eq((long) heartbeatInterval), Mockito.eq((long) heartbeatInterval),
-                    Mockito.eq(TimeUnit.MILLISECONDS))).thenReturn(pingFuture);
+            pingFuture = mock(ScheduledFuture.class);
+            when(executorService.scheduleWithFixedDelay(any(Runnable.class), eq((long) heartbeatInterval),
+                eq((long) heartbeatInterval), eq(TimeUnit.MILLISECONDS))).thenReturn(pingFuture);
         }
     }
 
@@ -50,14 +59,14 @@ public class WebSocketSessionHandlerTest {
         final int heartbeatInterval = 1000;
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(
                 1000, heartbeatInterval);
-        final Session session = Mockito.mock(Session.class);
+        final Session session = mock(Session.class);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
-        Mockito.verify(webSocketTestSessionState.listener).addSubscriber(
+        verify(webSocketTestSessionState.listener).addSubscriber(
                 webSocketTestSessionState.webSocketSessionHandler);
-        Mockito.verify(webSocketTestSessionState.executorService).scheduleWithFixedDelay(Mockito.any(Runnable.class),
-                Mockito.eq((long) webSocketTestSessionState.heartbeatInterval),
-                Mockito.eq((long) webSocketTestSessionState.heartbeatInterval), Mockito.eq(TimeUnit.MILLISECONDS));
+        verify(webSocketTestSessionState.executorService).scheduleWithFixedDelay(any(Runnable.class),
+                eq((long) webSocketTestSessionState.heartbeatInterval),
+                eq((long) webSocketTestSessionState.heartbeatInterval), eq(TimeUnit.MILLISECONDS));
     }
 
     @Test
@@ -65,36 +74,36 @@ public class WebSocketSessionHandlerTest {
         final int heartbeatInterval = 0;
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(
                 1000, heartbeatInterval);
-        final Session session = Mockito.mock(Session.class);
+        final Session session = mock(Session.class);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
-        Mockito.verify(webSocketTestSessionState.listener).addSubscriber(
+        verify(webSocketTestSessionState.listener).addSubscriber(
                 webSocketTestSessionState.webSocketSessionHandler);
-        Mockito.verifyZeroInteractions(webSocketTestSessionState.executorService);
+        verifyNoMoreInteractions(webSocketTestSessionState.executorService);
     }
 
     @Test
     public void onWebSocketConnectedWithAlreadyOpenSession() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
-        final Session session = Mockito.mock(Session.class);
-        Mockito.when(session.isOpen()).thenReturn(true);
+        final Session session = mock(Session.class);
+        when(session.isOpen()).thenReturn(true);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
-        Mockito.verify(webSocketTestSessionState.listener, Mockito.times(1)).addSubscriber(Mockito.any());
+        verify(webSocketTestSessionState.listener, times(1)).addSubscriber(any());
     }
 
     @Test
     public void onWebSocketClosedWithOpenSession() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(200, 10000);
-        final Session session = Mockito.mock(Session.class);
+        final Session session = mock(Session.class);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
-        Mockito.verify(webSocketTestSessionState.listener).addSubscriber(
+        verify(webSocketTestSessionState.listener).addSubscriber(
                 webSocketTestSessionState.webSocketSessionHandler);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketClosed(200, "Simulated close");
-        Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+        verify(webSocketTestSessionState.listener).removeSubscriber(
                 webSocketTestSessionState.webSocketSessionHandler);
     }
 
@@ -102,93 +111,93 @@ public class WebSocketSessionHandlerTest {
     public void onWebSocketClosedWithNotInitialisedSession() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(300, 12000);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketClosed(500, "Simulated close");
-        Mockito.verifyZeroInteractions(webSocketTestSessionState.listener);
+        verifyNoMoreInteractions(webSocketTestSessionState.listener);
     }
 
     @Test
     public void onWebSocketErrorWithEnabledPingAndLivingSession() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
-        final Session session = Mockito.mock(Session.class);
-        Mockito.when(session.isOpen()).thenReturn(true);
+        final Session session = mock(Session.class);
+        when(session.isOpen()).thenReturn(true);
         final Throwable sampleError = new IllegalStateException("Simulated error");
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
-        Mockito.when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
-        Mockito.when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(false);
+        when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
+        when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(false);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketError(sampleError);
-        Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+        verify(webSocketTestSessionState.listener).removeSubscriber(
                 webSocketTestSessionState.webSocketSessionHandler);
-        Mockito.verify(session).close();
-        Mockito.verify(webSocketTestSessionState.pingFuture).cancel(Mockito.anyBoolean());
+        verify(session).close();
+        verify(webSocketTestSessionState.pingFuture).cancel(anyBoolean());
     }
 
     @Test
     public void onWebSocketErrorWithEnabledPingAndDeadSession() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
-        final Session session = Mockito.mock(Session.class);
-        Mockito.when(session.isOpen()).thenReturn(false);
+        final Session session = mock(Session.class);
+        when(session.isOpen()).thenReturn(false);
         final Throwable sampleError = new IllegalStateException("Simulated error");
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketError(sampleError);
-        Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+        verify(webSocketTestSessionState.listener).removeSubscriber(
                 webSocketTestSessionState.webSocketSessionHandler);
-        Mockito.verify(session, Mockito.never()).close();
-        Mockito.verify(webSocketTestSessionState.pingFuture).cancel(Mockito.anyBoolean());
+        verify(session, never()).close();
+        verify(webSocketTestSessionState.pingFuture).cancel(anyBoolean());
     }
 
     @Test
     public void onWebSocketErrorWithDisabledPingAndDeadSession() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(150, 8000);
-        final Session session = Mockito.mock(Session.class);
-        Mockito.when(session.isOpen()).thenReturn(false);
+        final Session session = mock(Session.class);
+        when(session.isOpen()).thenReturn(false);
         final Throwable sampleError = new IllegalStateException("Simulated error");
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
-        Mockito.when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
-        Mockito.when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(true);
+        when(webSocketTestSessionState.pingFuture.isCancelled()).thenReturn(false);
+        when(webSocketTestSessionState.pingFuture.isDone()).thenReturn(true);
 
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketError(sampleError);
-        Mockito.verify(webSocketTestSessionState.listener).removeSubscriber(
+        verify(webSocketTestSessionState.listener).removeSubscriber(
                 webSocketTestSessionState.webSocketSessionHandler);
-        Mockito.verify(session, Mockito.never()).close();
-        Mockito.verify(webSocketTestSessionState.pingFuture, Mockito.never()).cancel(Mockito.anyBoolean());
+        verify(session, never()).close();
+        verify(webSocketTestSessionState.pingFuture, never()).cancel(anyBoolean());
     }
 
     @Test
     public void sendDataMessageWithDisabledFragmentation() throws IOException {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(0, 0);
-        final Session session = Mockito.mock(Session.class);
-        final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
-        Mockito.when(session.isOpen()).thenReturn(true);
-        Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+        final Session session = mock(Session.class);
+        final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+        when(session.isOpen()).thenReturn(true);
+        when(session.getRemote()).thenReturn(remoteEndpoint);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
 
         final String testMessage = generateRandomStringOfLength(100);
         webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
-        Mockito.verify(remoteEndpoint).sendString(testMessage);
+        verify(remoteEndpoint).sendString(testMessage);
     }
 
     @Test
     public void sendDataMessageWithDisabledFragAndDeadSession() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(0, 0);
-        final Session session = Mockito.mock(Session.class);
-        final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
-        Mockito.when(session.isOpen()).thenReturn(false);
-        Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+        final Session session = mock(Session.class);
+        final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+        when(session.isOpen()).thenReturn(false);
+        when(session.getRemote()).thenReturn(remoteEndpoint);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
 
         final String testMessage = generateRandomStringOfLength(11);
         webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
-        Mockito.verifyZeroInteractions(remoteEndpoint);
+        verifyNoMoreInteractions(remoteEndpoint);
     }
 
     @Test
     public void sendDataMessageWithEnabledFragAndSmallMessage() throws IOException {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
-        final Session session = Mockito.mock(Session.class);
-        final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
-        Mockito.when(session.isOpen()).thenReturn(true);
-        Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+        final Session session = mock(Session.class);
+        final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+        when(session.isOpen()).thenReturn(true);
+        when(session.getRemote()).thenReturn(remoteEndpoint);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
 
         // in both cases, fragmentation should not be applied
@@ -196,31 +205,31 @@ public class WebSocketSessionHandlerTest {
         final String testMessage2 = generateRandomStringOfLength(50);
         webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage1);
         webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage2);
-        Mockito.verify(remoteEndpoint).sendString(testMessage1);
-        Mockito.verify(remoteEndpoint).sendString(testMessage2);
-        Mockito.verify(remoteEndpoint, Mockito.never()).sendPartialString(Mockito.anyString(), Mockito.anyBoolean());
+        verify(remoteEndpoint).sendString(testMessage1);
+        verify(remoteEndpoint).sendString(testMessage2);
+        verify(remoteEndpoint, never()).sendPartialString(anyString(), anyBoolean());
     }
 
     @Test
     public void sendDataMessageWithZeroLength() {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
-        final Session session = Mockito.mock(Session.class);
-        final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
-        Mockito.when(session.isOpen()).thenReturn(true);
-        Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+        final Session session = mock(Session.class);
+        final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+        when(session.isOpen()).thenReturn(true);
+        when(session.getRemote()).thenReturn(remoteEndpoint);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
 
         webSocketTestSessionState.webSocketSessionHandler.sendDataMessage("");
-        Mockito.verifyZeroInteractions(remoteEndpoint);
+        verifyNoMoreInteractions(remoteEndpoint);
     }
 
     @Test
     public void sendDataMessageWithEnabledFragAndLargeMessage1() throws IOException {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
-        final Session session = Mockito.mock(Session.class);
-        final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
-        Mockito.when(session.isOpen()).thenReturn(true);
-        Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+        final Session session = mock(Session.class);
+        final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+        when(session.isOpen()).thenReturn(true);
+        when(session.getRemote()).thenReturn(remoteEndpoint);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
 
         // there should be 10 fragments of length 100 characters
@@ -228,23 +237,23 @@ public class WebSocketSessionHandlerTest {
         webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
         final ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
         final ArgumentCaptor<Boolean> isLastCaptor = ArgumentCaptor.forClass(Boolean.class);
-        Mockito.verify(remoteEndpoint, Mockito.times(10)).sendPartialString(
+        verify(remoteEndpoint, times(10)).sendPartialString(
                 messageCaptor.capture(), isLastCaptor.capture());
 
         final List<String> allMessages = messageCaptor.getAllValues();
         final List<Boolean> isLastFlags = isLastCaptor.getAllValues();
-        Assert.assertTrue(allMessages.stream().allMatch(s -> s.length() == webSocketTestSessionState.maxFragmentSize));
-        Assert.assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
-        Assert.assertTrue(isLastFlags.get(9));
+        assertTrue(allMessages.stream().allMatch(s -> s.length() == webSocketTestSessionState.maxFragmentSize));
+        assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
+        assertTrue(isLastFlags.get(9));
     }
 
     @Test
     public void sendDataMessageWithEnabledFragAndLargeMessage2() throws IOException {
         final WebSocketTestSessionState webSocketTestSessionState = new WebSocketTestSessionState(100, 0);
-        final Session session = Mockito.mock(Session.class);
-        final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
-        Mockito.when(session.isOpen()).thenReturn(true);
-        Mockito.when(session.getRemote()).thenReturn(remoteEndpoint);
+        final Session session = mock(Session.class);
+        final RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
+        when(session.isOpen()).thenReturn(true);
+        when(session.getRemote()).thenReturn(remoteEndpoint);
         webSocketTestSessionState.webSocketSessionHandler.onWebSocketConnected(session);
 
         // there should be 10 fragments, the last fragment should be the shortest one
@@ -252,16 +261,16 @@ public class WebSocketSessionHandlerTest {
         webSocketTestSessionState.webSocketSessionHandler.sendDataMessage(testMessage);
         final ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
         final ArgumentCaptor<Boolean> isLastCaptor = ArgumentCaptor.forClass(Boolean.class);
-        Mockito.verify(remoteEndpoint, Mockito.times(10)).sendPartialString(
+        verify(remoteEndpoint, times(10)).sendPartialString(
                 messageCaptor.capture(), isLastCaptor.capture());
 
         final List<String> allMessages = messageCaptor.getAllValues();
         final List<Boolean> isLastFlags = isLastCaptor.getAllValues();
-        Assert.assertTrue(allMessages.subList(0, 9).stream().allMatch(s ->
+        assertTrue(allMessages.subList(0, 9).stream().allMatch(s ->
                 s.length() == webSocketTestSessionState.maxFragmentSize));
-        Assert.assertEquals(50, allMessages.get(9).length());
-        Assert.assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
-        Assert.assertTrue(isLastFlags.get(9));
+        assertEquals(50, allMessages.get(9).length());
+        assertTrue(isLastFlags.subList(0, 9).stream().noneMatch(isLast -> isLast));
+        assertTrue(isLastFlags.get(9));
     }
 
     private static String generateRandomStringOfLength(final int length) {