Migrate tapi module to JUnit5

JIRA: TRNSPRTPCE-730
Signed-off-by: Gilles Thouenon <gilles.thouenon@orange.com>
Change-Id: Ie52cd9632fcc7bf9d7202782d4699a5e479e9f6c

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java
index c01c1e153150ce3dc5328879c81be6f0b134b336..bb0ae8789630a0ecdca6eb9cd47fc25b85b09abb 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java
@@ -7,7 +7,10 @@
  */
 package org.opendaylight.transportpce.tapi.connectivity;
 
  */
 package org.opendaylight.transportpce.tapi.connectivity;
 

+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;

 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.any;

+import static org.mockito.Mockito.when;

 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;


@@ -17,12 +20,11 @@ import java.util.HashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;

-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;

 import org.mockito.Mock;
 import org.mockito.Mock;

-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;

 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
 import org.opendaylight.transportpce.common.InstanceIdentifiers;
 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
 import org.opendaylight.transportpce.common.InstanceIdentifiers;
 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;


@@ -59,49 +61,42 @@ import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

+@ExtendWith(MockitoExtension.class)

 public class TapiConnectivityImplTest extends AbstractTest {
 
     @Mock
     private PathComputationService pathComputationService;
 public class TapiConnectivityImplTest extends AbstractTest {
 
     @Mock
     private PathComputationService pathComputationService;

-

     @Mock
     private RendererServiceOperations rendererServiceOperations;
     @Mock
     private RendererServiceOperations rendererServiceOperations;

-

     @Mock
     private NotificationPublishService notificationPublishService;
     @Mock
     private NotificationPublishService notificationPublishService;

-

     @Mock
     private TapiPceListenerImpl tapipceListenerImpl;
     @Mock
     private TapiPceListenerImpl tapipceListenerImpl;

-

     @Mock
     private TapiRendererListenerImpl tapirendererListenerImpl;
     @Mock
     private TapiRendererListenerImpl tapirendererListenerImpl;

-

     @Mock
     private TapiServiceHandlerListenerImpl tapiserviceHandlerListenerImpl;
     @Mock
     private TapiServiceHandlerListenerImpl tapiserviceHandlerListenerImpl;

-

     @Mock
     private PceListenerImpl pceListenerImpl;
     @Mock
     private PceListenerImpl pceListenerImpl;

-

     @Mock
     private RendererListenerImpl rendererListenerImpl;
     @Mock
     private RendererListenerImpl rendererListenerImpl;

-

     @Mock
     private NetworkModelListenerImpl networkModelListenerImpl;
 
     private static final Logger LOG = LoggerFactory.getLogger(TapiConnectivityImplTest.class);
     @Mock
     private NetworkModelListenerImpl networkModelListenerImpl;
 
     private static final Logger LOG = LoggerFactory.getLogger(TapiConnectivityImplTest.class);

-    public static ServiceDataStoreOperations serviceDataStoreOperations;
-    public static TapiContext tapiContext;
-    public static TopologyUtils topologyUtils;
-    public static ConnectivityUtils connectivityUtils;
-    public static TapiInitialORMapping tapiInitialORMapping;
-    public static NetworkTransactionService networkTransactionService;
-    public static TapiLink tapilink;
+    private static ServiceDataStoreOperations serviceDataStoreOperations;
+    private static TapiContext tapiContext;
+    private static TopologyUtils topologyUtils;
+    private static ConnectivityUtils connectivityUtils;
+    private static TapiInitialORMapping tapiInitialORMapping;
+    private static NetworkTransactionService networkTransactionService;
+    private static TapiLink tapilink;

     private ListeningExecutorService executorService;
     private CountDownLatch endSignal;
     private static final int NUM_THREADS = 5;
 
     private ListeningExecutorService executorService;
     private CountDownLatch endSignal;
     private static final int NUM_THREADS = 5;
 

-    @Before
-    public void setUp() throws InterruptedException, ExecutionException {
+    @BeforeEach
+    void setUp() throws InterruptedException, ExecutionException {

         executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS));
         endSignal = new CountDownLatch(1);
         // Need to have datastore populated to enable the mapping from TAPI to OR
         executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS));
         endSignal = new CountDownLatch(1);
         // Need to have datastore populated to enable the mapping from TAPI to OR


@@ -114,8 +109,6 @@ public class TapiConnectivityImplTest extends AbstractTest {
         TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(),
             TapiTopologyDataUtils.PORTMAPPING_FILE);
 
         TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(),
             TapiTopologyDataUtils.PORTMAPPING_FILE);
 

-        MockitoAnnotations.openMocks(this);
-

         networkTransactionService = new NetworkTransactionImpl(getDataBroker());
         tapilink = new TapiLink(networkTransactionService);
         serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getDataStoreContextUtil().getDataBroker());
         networkTransactionService = new NetworkTransactionImpl(getDataBroker());
         tapilink = new TapiLink(networkTransactionService);
         serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getDataStoreContextUtil().getDataBroker());


@@ -131,7 +124,7 @@ public class TapiConnectivityImplTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void createConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
+    void createConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {

         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
             networkModelListenerImpl, serviceDataStoreOperations);
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
             networkModelListenerImpl, serviceDataStoreOperations);


@@ -151,18 +144,18 @@ public class TapiConnectivityImplTest extends AbstractTest {
         endSignal.await();
 
         RpcResult<CreateConnectivityServiceOutput> rpcResult = result.get();
         endSignal.await();
 
         RpcResult<CreateConnectivityServiceOutput> rpcResult = result.get();

-        Assert.assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType());
+        assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType());

     }
 
     @Test
     }
 
     @Test

-    public void createConnServiceShouldBeSuccessfulWhenPerformPCESuccessful()
+    void createConnServiceShouldBeSuccessfulWhenPerformPCESuccessful()

             throws ExecutionException, InterruptedException {
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
             networkModelListenerImpl, serviceDataStoreOperations);
 
         CreateConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceCreateInput();
             throws ExecutionException, InterruptedException {
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
             networkModelListenerImpl, serviceDataStoreOperations);
 
         CreateConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceCreateInput();

-        Mockito.when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any()));
+        when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any()));

 
         TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils,
             tapipceListenerImpl, tapirendererListenerImpl);
 
         TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils,
             tapipceListenerImpl, tapirendererListenerImpl);


@@ -178,11 +171,11 @@ public class TapiConnectivityImplTest extends AbstractTest {
         endSignal.await();
 
         RpcResult<CreateConnectivityServiceOutput> rpcResult = result.get();
         endSignal.await();
 
         RpcResult<CreateConnectivityServiceOutput> rpcResult = result.get();

-        Assert.assertTrue(rpcResult.isSuccessful());
+        assertTrue(rpcResult.isSuccessful());

     }
 
     @Test
     }
 
     @Test

-    public void deleteConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
+    void deleteConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {

         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
             networkModelListenerImpl, serviceDataStoreOperations);
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
             networkModelListenerImpl, serviceDataStoreOperations);


@@ -202,11 +195,11 @@ public class TapiConnectivityImplTest extends AbstractTest {
         endSignal.await();
 
         RpcResult<DeleteConnectivityServiceOutput> rpcResult = result.get();
         endSignal.await();
 
         RpcResult<DeleteConnectivityServiceOutput> rpcResult = result.get();

-        Assert.assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType());
+        assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType());

     }
 
     @Test
     }
 
     @Test

-    public void deleteConnServiceShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException {
+    void deleteConnServiceShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException {

         DeleteConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceDeleteInput1();
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
         DeleteConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceDeleteInput1();
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,


@@ -226,12 +219,12 @@ public class TapiConnectivityImplTest extends AbstractTest {
         endSignal.await();
 
         RpcResult<DeleteConnectivityServiceOutput> rpcResult = result.get();
         endSignal.await();
 
         RpcResult<DeleteConnectivityServiceOutput> rpcResult = result.get();

-        Assert.assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType());
+        assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType());

     }
 
     @Test
     }
 
     @Test

-    public void deleteConnServiceShouldBeSuccessForExistingService() throws ExecutionException, InterruptedException {
-        Mockito.when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any()));
+    void deleteConnServiceShouldBeSuccessForExistingService() throws ExecutionException, InterruptedException {
+        when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any()));

 
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
 
         OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService,
             rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,


@@ -257,6 +250,6 @@ public class TapiConnectivityImplTest extends AbstractTest {
         endSignal.await();
 
         RpcResult<DeleteConnectivityServiceOutput> rpcResult = result.get();
         endSignal.await();
 
         RpcResult<DeleteConnectivityServiceOutput> rpcResult = result.get();

-        Assert.assertTrue(rpcResult.isSuccessful());
+        assertTrue(rpcResult.isSuccessful());

     }
     }

-}
+}
\ No newline at end of file

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java
index c571f2af2fec33f70d6a8e33cbd449af4d3ef5f3..76077e6fb6ffe52686f9091cab8da49686570a79 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java
@@ -11,12 +11,11 @@ import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 

-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;

 import org.mockito.Mock;
 import org.mockito.Mock;

-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;

 import org.opendaylight.mdsal.binding.api.RpcProviderService;
 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
 import org.opendaylight.mdsal.binding.api.RpcProviderService;
 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
 import org.opendaylight.transportpce.common.network.NetworkTransactionService;


@@ -37,59 +36,43 @@ import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Tapi
 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.TapiConnectivityService;
 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.TapiTopologyService;
 
 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.TapiConnectivityService;
 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.TapiTopologyService;
 

+@ExtendWith(MockitoExtension.class)

 public class TapiProviderTest extends AbstractTest {
 public class TapiProviderTest extends AbstractTest {

-    public static NetworkTransactionService networkTransactionService;
+    private static NetworkTransactionService networkTransactionService;

 
     @Mock
 
     @Mock

-    RpcProviderService rpcProviderRegistry;
-
+    private RpcProviderService rpcProviderRegistry;

     @Mock
     @Mock

-    OrgOpenroadmServiceService serviceHandler;
-
+    private OrgOpenroadmServiceService serviceHandler;

     @Mock
     @Mock

-    ServiceDataStoreOperations serviceDataStoreOperations;
-
+    private ServiceDataStoreOperations serviceDataStoreOperations;

     @Mock
     @Mock

-    TapiListener tapiListener;
-
+    private TapiListener tapiListener;

     @Mock
     @Mock

-    TransportpceTapinetworkutilsService tapiNetworkUtils;
-
+    private TransportpceTapinetworkutilsService tapiNetworkUtils;

     @Mock
     @Mock

-    TapiPortMappingListener tapiPortMappingListener;
-
+    private TapiPortMappingListener tapiPortMappingListener;

     @Mock
     @Mock

-    TapiNetconfTopologyListener topologyListener;
-
+    private TapiNetconfTopologyListener topologyListener;

     @Mock
     @Mock

-    TapiOrLinkListener orLinkListener;
-
+    private TapiOrLinkListener orLinkListener;

     @Mock
     @Mock

-    TapiPceListenerImpl pceListenerImpl;
-
+    private TapiPceListenerImpl pceListenerImpl;

     @Mock
     @Mock

-    TapiRendererListenerImpl rendererListenerImpl;
-
+    private TapiRendererListenerImpl rendererListenerImpl;

     @Mock
     @Mock

-    TapiServiceHandlerListenerImpl serviceHandlerListenerImpl;
-
+    private TapiServiceHandlerListenerImpl serviceHandlerListenerImpl;

     @Mock
     @Mock

-    TapiNetworkModelListenerImpl networkModelListener;
+    private TapiNetworkModelListenerImpl networkModelListener;

 
 

-    private AutoCloseable closeable;

 
 

-    @Before
-    public void openMocks() {
-        closeable = MockitoAnnotations.openMocks(this);
-    }
-
-    @BeforeClass
-    public static void setUp() {
+    @BeforeAll
+    static void setUp() {

         networkTransactionService = new NetworkTransactionImpl(getDataBroker());
     }
 
     @Test
         networkTransactionService = new NetworkTransactionImpl(getDataBroker());
     }
 
     @Test

-    public void testInitRegisterTapiToRpcRegistry() {
+    void testInitRegisterTapiToRpcRegistry() {

         TapiProvider provider =  new TapiProvider(getDataBroker(), rpcProviderRegistry, serviceHandler,
             serviceDataStoreOperations, tapiListener, networkTransactionService, topologyListener,
             tapiPortMappingListener, tapiNetworkUtils, pceListenerImpl, rendererListenerImpl,
         TapiProvider provider =  new TapiProvider(getDataBroker(), rpcProviderRegistry, serviceHandler,
             serviceDataStoreOperations, tapiListener, networkTransactionService, topologyListener,
             tapiPortMappingListener, tapiNetworkUtils, pceListenerImpl, rendererListenerImpl,


@@ -97,16 +80,8 @@ public class TapiProviderTest extends AbstractTest {
 
         provider.init();
 
 
         provider.init();
 

-        verify(rpcProviderRegistry, times(1))
-            .registerRpcImplementation(any(), any(TapiConnectivityService.class));
-        verify(rpcProviderRegistry, times(2))
-            .registerRpcImplementation(any(), any(TapiTopologyService.class));
-        verify(rpcProviderRegistry, times(2))
-            .registerRpcImplementation(any(), any(TapiCommonService.class));
-    }
-
-    @After
-    public void releaseMocks() throws Exception {
-        closeable.close();
+        verify(rpcProviderRegistry, times(1)).registerRpcImplementation(any(), any(TapiConnectivityService.class));
+        verify(rpcProviderRegistry, times(2)).registerRpcImplementation(any(), any(TapiTopologyService.class));
+        verify(rpcProviderRegistry, times(2)).registerRpcImplementation(any(), any(TapiCommonService.class));

     }
     }

-}
+}
\ No newline at end of file

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java
index dca654dfc46524974f4a05cfa7f264cce4103b47..272caa5b28e3616d7272a3faf1b0b11489a3aa19 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java
@@ -14,10 +14,10 @@ import static org.hamcrest.CoreMatchers.hasItem;
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;

-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;

 
 import com.google.common.util.concurrent.FluentFuture;
 import java.nio.charset.Charset;
 
 import com.google.common.util.concurrent.FluentFuture;
 import java.nio.charset.Charset;


@@ -30,8 +30,8 @@ import java.util.UUID;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.Nullable;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.Nullable;

-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;

 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.transportpce.common.InstanceIdentifiers;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.transportpce.common.InstanceIdentifiers;


@@ -115,8 +115,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     private static TapiLink tapiLink;
     private static DataBroker dataBroker = getDataBroker();
 
     private static TapiLink tapiLink;
     private static DataBroker dataBroker = getDataBroker();
 

-    @BeforeClass
-    public static void setUp() throws InterruptedException, ExecutionException {
+    @BeforeAll
+    static void setUp() throws InterruptedException, ExecutionException {

         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
             TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
             TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),


@@ -201,7 +201,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeWhenNoStates() {
+    void convertNodeWhenNoStates() {

         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1",  null, null);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1",  null, null);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -224,12 +224,12 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid));

-        assertNull("Administrative State should not be present", enepN.getAdministrativeState());
-        assertNull("Operational State should not be present", enepN.getOperationalState());
+        assertNull(enepN.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(enepN.getOperationalState(), "Operational State should not be present");

 
         OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid));
 
         OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid));

-        assertNull("Administrative State should not be present", inepN.getAdministrativeState());
-        assertNull("Operational State should not be present", inepN.getOperationalState());
+        assertNull(inepN.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(inepN.getOperationalState(), "Operational State should not be present");

 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -240,26 +240,26 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));

-        assertNull("Administrative State should not be present", enep.getAdministrativeState());
-        assertNull("Operational State should not be present", enep.getOperationalState());
+        assertNull(enep.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(enep.getOperationalState(), "Operational State should not be present");

 
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
 
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));

-        assertNull("Administrative State should not be present", inep.getAdministrativeState());
-        assertNull("Operational State should not be present", inep.getOperationalState());
+        assertNull(inep.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(inep.getOperationalState(), "Operational State should not be present");

 
         Uuid photnepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid));
 
         Uuid photnepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid));

-        assertNull("Administrative State should not be present", photnep.getAdministrativeState());
-        assertNull("Operational State should not be present", photnep.getOperationalState());
+        assertNull(photnep.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(photnep.getOperationalState(), "Operational State should not be present");

     }
 
     @Test
     }
 
     @Test

-    public void convertNodeWhenBadStates1() {
+    void convertNodeWhenBadStates1() {

         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1",
             AdminStates.OutOfService, State.OutOfService);
         List<String> networkPortList = new ArrayList<>();
         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1",
             AdminStates.OutOfService, State.OutOfService);
         List<String> networkPortList = new ArrayList<>();


@@ -283,16 +283,14 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, enepN.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, enepN.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, enepN.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, enepN.getOperationalState(), "Operational State should be Disabled");

 
         OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid));
 
         OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, inepN.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, inepN.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, inepN.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, inepN.getOperationalState(), "Operational State should be Disabled");

 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -303,32 +301,29 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, enep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, enep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled");

 
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
 
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, inep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, inep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled");

 
         Uuid photnepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid));
 
         Uuid photnepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, photnep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, photnep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, photnep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, photnep.getOperationalState(), "Operational State should be Disabled");

     }
 
     @Test
     }
 
     @Test

-    public void convertNodeWhenBadStates2() {
+    void convertNodeWhenBadStates2() {

         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1",
             AdminStates.Maintenance, State.Degraded);
         List<String> networkPortList = new ArrayList<>();
         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1",
             AdminStates.Maintenance, State.Degraded);
         List<String> networkPortList = new ArrayList<>();


@@ -352,16 +347,14 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, enepN.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, enepN.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, enepN.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, enepN.getOperationalState(), "Operational State should be Disabled");

 
         OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid));
 
         OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, inepN.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, inepN.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, inepN.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, inepN.getOperationalState(), "Operational State should be Disabled");

 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -372,32 +365,29 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, enep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, enep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled");

 
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
 
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, inep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, inep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled");

 
         Uuid photnepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid));
 
         Uuid photnepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, photnep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, photnep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, photnep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, photnep.getOperationalState(), "Operational State should be Disabled");

     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForTransponder100G() {
+    void convertNodeForTransponder100G() {

         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -411,8 +401,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 

-        assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size());
+        assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2");
+        assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2");

 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -430,7 +420,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForOtnMuxponder() {
+    void convertNodeForOtnMuxponder() {

         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -444,8 +434,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 

-        assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size());
+        assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2");
+        assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1");

         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
         checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1");
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
         checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1");


@@ -462,7 +452,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForOtnSwitch() {
+    void convertNodeForOtnSwitch() {

         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -476,8 +466,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 

-        assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size());
+        assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2");
+        assertEquals(4, tapiFactory.getTapiLinks().size(), "Link list size should be 4");

 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -495,12 +485,12 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForRoadmWhenNoOtnMuxAttached() {
+    void convertNodeForRoadmWhenNoOtnMuxAttached() {

         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         tapiFactory.convertRoadmNode(roadmA, openroadmNet);
 
         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         tapiFactory.convertRoadmNode(roadmA, openroadmNet);
 

-        assertEquals("Node list size should be 1", 1, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be empty", 0, tapiFactory.getTapiLinks().size());
+        assertEquals(1, tapiFactory.getTapiNodes().size(), "Node list size should be 1");
+        assertEquals(0, tapiFactory.getTapiLinks().size(), "Link list size should be empty");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList());
         Uuid roadmNodeUuid = new Uuid(UUID.nameUUIDFromBytes((roadmA.getNodeId().getValue() + "+PHOTONIC_MEDIA")
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList());
         Uuid roadmNodeUuid = new Uuid(UUID.nameUUIDFromBytes((roadmA.getNodeId().getValue() + "+PHOTONIC_MEDIA")


@@ -509,7 +499,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForRoadmWhenRoadmNeighborAttached() {
+    void convertNodeForRoadmWhenRoadmNeighborAttached() {

         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         tapiFactory.convertRoadmNode(roadmA, openroadmNet);
         tapiFactory.convertRoadmNode(roadmC, openroadmNet);
         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         tapiFactory.convertRoadmNode(roadmA, openroadmNet);
         tapiFactory.convertRoadmNode(roadmC, openroadmNet);


@@ -519,8 +509,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             .collect(Collectors.toList());
         tapiFactory.convertRdmToRdmLinks(rdmTordmLinkList);
 
             .collect(Collectors.toList());
         tapiFactory.convertRdmToRdmLinks(rdmTordmLinkList);
 

-        assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size());
+        assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2");
+        assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1");

 
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList());
 
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList());


@@ -549,7 +539,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForRoadmWhenOtnMuxAttached() {
+    void convertNodeForRoadmWhenOtnMuxAttached() {

         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortListA = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink);
         List<String> networkPortListA = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -575,8 +565,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             .collect(Collectors.toList());
         xponderInLinkList.addAll(xponderOutLinkList);
         tapiFactory.convertXpdrToRdmLinks(xponderInLinkList);
             .collect(Collectors.toList());
         xponderInLinkList.addAll(xponderOutLinkList);
         tapiFactory.convertXpdrToRdmLinks(xponderInLinkList);

-        assertEquals("Node list size should be 3", 3, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size());
+        assertEquals(3, tapiFactory.getTapiNodes().size(), "Node list size should be 3");
+        assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream()
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream()
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))


@@ -606,18 +596,17 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
     }
 
     private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,

-                              Uuid nodeUuid, String dsrNodeType, String nodeId) {
-        assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
-        assertEquals("incorrect node name", nodeId + "+DSR", node.getName().get(
-            new NameKey("dsr/odu node name")).getValue());
-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, node.getAdministrativeState());
-        assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
-        assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
+            Uuid nodeUuid, String dsrNodeType, String nodeId) {
+        assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid");
+        assertEquals(nodeId + "+DSR", node.getName().get(new NameKey("dsr/odu node name")).getValue(),
+            "incorrect node name");
+        assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(),
+            "administrative state should be UNLOCKED");
+        assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED");
+        assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED");

         assertThat("one value-name should be 'dsr/odu node name'",
             new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("dsr/odu node name")));
         assertThat("one value-name should be 'dsr/odu node name'",
             new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("dsr/odu node name")));

-        assertEquals("dsr node should manage 2 protocol layers : dsr and odu",
-            2, node.getLayerProtocolName().size());
+        assertEquals(2, node.getLayerProtocolName().size(), "dsr node should manage 2 protocol layers : dsr and odu");

         assertThat("dsr node should manage 2 protocol layers : dsr and odu",
             node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU));
         List<OwnedNodeEdgePoint> inepsN = node.nonnullOwnedNodeEdgePoint().values().stream()
         assertThat("dsr node should manage 2 protocol layers : dsr and odu",
             node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU));
         List<OwnedNodeEdgePoint> inepsN = node.nonnullOwnedNodeEdgePoint().values().stream()


@@ -635,9 +624,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                     .collect(Collectors.toList());
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                     .collect(Collectors.toList());

-                assertEquals("Switch-DSR node should have 4 eNEPs network", 4, enepsN.size());
-                assertEquals("Switch-DSR node should have 4 iNEPs network", 4, inepsN.size());
-                assertEquals("Switch-DSR node should have 4 NEPs client", 4, nepsC.size());
+                assertEquals(4, enepsN.size(), "Switch-DSR node should have 4 eNEPs network");
+                assertEquals(4, inepsN.size(), "Switch-DSR node should have 4 iNEPs network");
+                assertEquals(4, nepsC.size(), "Switch-DSR node should have 4 NEPs client");

                 OwnedNodeEdgePoint nep1 = nepsC.get(2);
                 Uuid client4NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-CLIENT4").getBytes(Charset.forName("UTF-8")))
                 OwnedNodeEdgePoint nep1 = nepsC.get(2);
                 Uuid client4NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-CLIENT4").getBytes(Charset.forName("UTF-8")))


@@ -663,9 +652,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep3, nep4) -> nep3.getUuid().getValue().compareTo(nep4.getUuid().getValue()))
                     .collect(Collectors.toList());
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep3, nep4) -> nep3.getUuid().getValue().compareTo(nep4.getUuid().getValue()))
                     .collect(Collectors.toList());

-                assertEquals("Mux-DSR node should have 4 eNEP network", 4, enepsN.size());
-                assertEquals("Mux-DSR node should have 1 iNEP network", 1, inepsN.size());
-                assertEquals("Mux-DSR node should have 4 NEPs client", 4, nepsC.size());
+                assertEquals(4, enepsN.size(), "Mux-DSR node should have 4 eNEP network");
+                assertEquals(1, inepsN.size(), "Mux-DSR node should have 1 iNEP network");
+                assertEquals(4, nepsC.size(), "Mux-DSR node should have 4 NEPs client");

                 OwnedNodeEdgePoint nep3 = nepsC.get(2);
                 Uuid client3NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT3").getBytes(Charset.forName("UTF-8")))
                 OwnedNodeEdgePoint nep3 = nepsC.get(2);
                 Uuid client3NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT3").getBytes(Charset.forName("UTF-8")))


@@ -692,9 +681,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                     .filter(n -> n.getName().containsKey(new NameKey("100G-tpdr")))
                     .sorted((nep5, nep6) -> nep5.getUuid().getValue().compareTo(nep6.getUuid().getValue()))
                     .collect(Collectors.toList());
                     .filter(n -> n.getName().containsKey(new NameKey("100G-tpdr")))
                     .sorted((nep5, nep6) -> nep5.getUuid().getValue().compareTo(nep6.getUuid().getValue()))
                     .collect(Collectors.toList());

-                assertEquals("Tpdr-DSR node should have 2 eNEPs network", 2, enepsN.size());
-                assertEquals("Tpdr-DSR node should have 2 iNEPs network", 2, inepsN.size());
-                assertEquals("Tpdr-DSR node should have 2 NEPs client", 2, nepsC.size());
+                assertEquals(2, enepsN.size(), "Tpdr-DSR node should have 2 eNEPs network");
+                assertEquals(2, inepsN.size(), "Tpdr-DSR node should have 2 iNEPs network");
+                assertEquals(2, nepsC.size(), "Tpdr-DSR node should have 2 NEPs client");

                 OwnedNodeEdgePoint nep5 = nepsC.get(0);
                 Uuid client1NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT1").getBytes(Charset.forName("UTF-8")))
                 OwnedNodeEdgePoint nep5 = nepsC.get(0);
                 Uuid client1NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT1").getBytes(Charset.forName("UTF-8")))


@@ -725,7 +714,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     private void checkOtsiNode(
             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
             Uuid nodeUuid, String otsiNodeType, String nodeId) {
     private void checkOtsiNode(
             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
             Uuid nodeUuid, String otsiNodeType, String nodeId) {

-        assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
+        assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid");

         List<OwnedNodeEdgePoint> nepsI = null;
         List<OwnedNodeEdgePoint> nepsE = null;
         List<OwnedNodeEdgePoint> nepsP = null;
         List<OwnedNodeEdgePoint> nepsI = null;
         List<OwnedNodeEdgePoint> nepsE = null;
         List<OwnedNodeEdgePoint> nepsP = null;


@@ -733,8 +722,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
         List<OwnedNodeEdgePoint> nepsOtsimc = null;
         List<OwnedNodeEdgePoint> nepsPhot = null;
         if (!otsiNodeType.equals("roadm")) {
         List<OwnedNodeEdgePoint> nepsOtsimc = null;
         List<OwnedNodeEdgePoint> nepsPhot = null;
         if (!otsiNodeType.equals("roadm")) {

-            assertEquals("incorrect node name", nodeId + "+OTSi", node.getName().get(
-                new NameKey("otsi node name")).getValue());
+            assertEquals(nodeId + "+OTSi", node.getName().get(new NameKey("otsi node name")).getValue(),
+                "incorrect node name");

             assertThat("one value-name should be 'dsr/odu node name'",
                 new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("otsi node name")));
             nepsI = node.nonnullOwnedNodeEdgePoint().values().stream()
             assertThat("one value-name should be 'dsr/odu node name'",
                 new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("otsi node name")));
             nepsI = node.nonnullOwnedNodeEdgePoint().values().stream()


@@ -750,8 +739,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                 .collect(Collectors.toList());
         } else {
                 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                 .collect(Collectors.toList());
         } else {

-            assertEquals("incorrect node name", nodeId + "+PHOTONIC_MEDIA", node.getName().get(
-                new NameKey("roadm node name")).getValue());
+            assertEquals(nodeId + "+PHOTONIC_MEDIA", node.getName().get(new NameKey("roadm node name")).getValue(),
+                "incorrect node name");

             assertThat("one value-name should be 'dsr/odu node name'",
                 new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("roadm node name")));
             nepsMc = node.nonnullOwnedNodeEdgePoint().values().stream()
             assertThat("one value-name should be 'dsr/odu node name'",
                 new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("roadm node name")));
             nepsMc = node.nonnullOwnedNodeEdgePoint().values().stream()


@@ -767,20 +756,20 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                 .collect(Collectors.toList());
         }
                 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                 .collect(Collectors.toList());
         }

-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, node.getAdministrativeState());
-        assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
-        assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
-        assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
-            1, node.getLayerProtocolName().size());
-        assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
-            LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().stream().findFirst().get());
+        assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(),
+            "administrative state should be UNLOCKED");
+        assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED");
+        assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED");
+        assertEquals(1, node.getLayerProtocolName().size(),
+            "otsi node should manage a single protocol layer : PHOTONIC_MEDIA");
+        assertEquals(LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().stream().findFirst().get(),
+            "otsi node should manage a single protocol layer : PHOTONIC_MEDIA");

 
         switch (otsiNodeType) {
             case "switch":
 
         switch (otsiNodeType) {
             case "switch":

-                assertEquals("Switch-OTSi node should have 4 eNEPs", 4, nepsE.size());
-                assertEquals("Switch-OTSi node should have 4 iNEPs", 4, nepsI.size());
-                assertEquals("Switch-OTSi node should have 4 photNEPs", 4, nepsP.size());
+                assertEquals(4, nepsE.size(), "Switch-OTSi node should have 4 eNEPs");
+                assertEquals(4, nepsI.size(), "Switch-OTSi node should have 4 iNEPs");
+                assertEquals(4, nepsP.size(), "Switch-OTSi node should have 4 photNEPs");

                 OwnedNodeEdgePoint nep1 = nepsI.get(1);
                 Uuid inepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8")))
                 OwnedNodeEdgePoint nep1 = nepsI.get(1);
                 Uuid inepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8")))


@@ -803,9 +792,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                 checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid);
                 break;
             case "mux":
                 checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid);
                 break;
             case "mux":

-                assertEquals("Mux-OTSi node should have 1 eNEP", 1, nepsE.size());
-                assertEquals("Mux-OTSi node should have 1 iNEPs", 1, nepsI.size());
-                assertEquals("Mux-OTSi node should have 1 photNEPs", 1, nepsP.size());
+                assertEquals(1, nepsE.size(), "Mux-OTSi node should have 1 eNEP");
+                assertEquals(1, nepsI.size(), "Mux-OTSi node should have 1 iNEPs");
+                assertEquals(1, nepsP.size(), "Mux-OTSi node should have 1 photNEPs");

                 OwnedNodeEdgePoint nep3 = nepsE.get(0);
                 Uuid enepUuid2 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 OwnedNodeEdgePoint nep3 = nepsE.get(0);
                 Uuid enepUuid2 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))


@@ -828,9 +817,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                 checkNodeRuleGroupForMuxOTSi(nrgList2, enepUuid2, inepUuid2, nodeUuid);
                 break;
             case "tpdr":
                 checkNodeRuleGroupForMuxOTSi(nrgList2, enepUuid2, inepUuid2, nodeUuid);
                 break;
             case "tpdr":

-                assertEquals("Tpdr-OTSi node should have 2 eNEPs", 2, nepsE.size());
-                assertEquals("Tpdr-OTSi node should have 2 iNEPs", 2, nepsI.size());
-                assertEquals("Tpdr-OTSi node should have 2 photNEPs", 2, nepsP.size());
+                assertEquals(2, nepsE.size(), "Tpdr-OTSi node should have 2 eNEPs");
+                assertEquals(2, nepsI.size(), "Tpdr-OTSi node should have 2 iNEPs");
+                assertEquals(2, nepsP.size(), "Tpdr-OTSi node should have 2 photNEPs");

                 OwnedNodeEdgePoint nep5 = nepsE.get(0);
                 Uuid enepUuid3 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 OwnedNodeEdgePoint nep5 = nepsE.get(0);
                 Uuid enepUuid3 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))


@@ -853,9 +842,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
                 checkNodeRuleGroupForTpdrOTSi(nrgList3, enepUuid3, inepUuid3, nodeUuid);
                 break;
             case "roadm":
                 checkNodeRuleGroupForTpdrOTSi(nrgList3, enepUuid3, inepUuid3, nodeUuid);
                 break;
             case "roadm":

-                assertEquals("Roadm node should have 10 MC NEPs", 10, nepsMc.size());
-                assertEquals("Roadm node should have 10 OTSiMC NEPs", 10, nepsOtsimc.size());
-                assertEquals("Roadm node should have 10 PHOT_MEDIA NEPs", 10, nepsPhot.size());
+                assertEquals(10, nepsMc.size(), "Roadm node should have 10 MC NEPs");
+                assertEquals(10, nepsOtsimc.size(), "Roadm node should have 10 OTSiMC NEPs");
+                assertEquals(10, nepsPhot.size(), "Roadm node should have 10 PHOT_MEDIA NEPs");

                 // For Degree node
                 OwnedNodeEdgePoint nep7 = nepsMc.get(6);
                 Uuid mcnepUuid3 = new Uuid(
                 // For Degree node
                 OwnedNodeEdgePoint nep7 = nepsMc.get(6);
                 Uuid mcnepUuid3 = new Uuid(


@@ -902,66 +891,62 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
     }
 
     private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
     }
 
     private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);

-        assertEquals("value of client nep should be '" + portName + "'",
-            portName, name.getValue());
-        assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
-            nepName, name.getValueName());
-        assertEquals("Client nep should support 3 kind of cep",
-            3, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(portName, name.getValue(), "value of client nep should be '" + portName + "'");
+        assertEquals(nepName, name.getValueName(),
+            "value-name of client nep for '" + portName + "' should be '" + nepName + "'");
+        assertEquals(3, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 3 kind of cep");

         assertThat("client nep should support 3 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU2.VALUE, ODUTYPEODU2E.VALUE, DIGITALSIGNALTYPE10GigELAN.VALUE));
         assertThat("client nep should support 3 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU2.VALUE, ODUTYPEODU2E.VALUE, DIGITALSIGNALTYPE10GigELAN.VALUE));

-        assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.DSR, nep.getLayerProtocolName(), "client nep should be of DSR protocol type");

         checkCommonPartOfNep(nep, false);
     }
 
     private void checkNepeODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
         checkCommonPartOfNep(nep, false);
     }
 
     private void checkNepeODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,

-                                     boolean withSip) {
-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+            boolean withSip) {
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);

-        assertEquals("value of eODU nep should be '" + portName + "'",
-            portName, name.getValue());
-        assertEquals("value-name of eODU nep for '" + portName + "' should be '" + nepName + "'",
-            nepName, name.getValueName());
+        assertEquals(portName, name.getValue(), "value of eODU nep should be '" + portName + "'");
+        assertEquals(nepName, name.getValueName(),
+            "value-name of eODU nep for '" + portName + "' should be '" + nepName + "'");

         // TODO: depending on the type of node there is one type or another
         assertThat("eODU nep should support 1, 2 or 3 kind of cep, depending on client port",
             nep.getSupportedCepLayerProtocolQualifier().size(), anyOf(is(1), is(2), is(3)));
         // TODO: depending on the type of node there is one type or another
         assertThat("eODU nep should support 1, 2 or 3 kind of cep, depending on client port",
             nep.getSupportedCepLayerProtocolQualifier().size(), anyOf(is(1), is(2), is(3)));

-        assertTrue("eODU nep should support 1 kind of cep",
+        assertTrue(

             nep.getSupportedCepLayerProtocolQualifier().stream().anyMatch(splc -> splc.equals(ODUTYPEODU0.VALUE)
                 || splc.equals(ODUTYPEODU2.VALUE) || splc.equals(ODUTYPEODU2E.VALUE)
             nep.getSupportedCepLayerProtocolQualifier().stream().anyMatch(splc -> splc.equals(ODUTYPEODU0.VALUE)
                 || splc.equals(ODUTYPEODU2.VALUE) || splc.equals(ODUTYPEODU2E.VALUE)

-                || splc.equals(ODUTYPEODU4.VALUE)));
-        assertEquals("eODU nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName());
+                || splc.equals(ODUTYPEODU4.VALUE)),
+            "eODU nep should support 1 kind of cep");
+        assertEquals(LayerProtocolName.ODU, nep.getLayerProtocolName(), "eODU nep should be of ODU protocol type");

         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,

-                                     boolean withSip) {
-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+            boolean withSip) {
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);

-        assertEquals("value of network nep should be '" + portName + "'",
-            portName, name.getValue());
-        assertEquals("value-name of network nep for '" + portName + "' should be '" + nepName + "'",
-            nepName, name.getValueName());
-        assertEquals("Network nep should support 1 kind of cep",
-            1, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(portName, name.getValue(), "value of network nep should be '" + portName + "'");
+        assertEquals(nepName, name.getValueName(),
+            "value-name of network nep for '" + portName + "' should be '" + nepName + "'");
+        assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), "Network nep should support 1 kind of cep");

         assertThat("network nep should support 1 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItem(ODUTYPEODU4.VALUE));
         assertThat("network nep should support 1 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItem(ODUTYPEODU4.VALUE));

-        assertEquals("network nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.ODU, nep.getLayerProtocolName(), "network nep should be of ODU protocol type");

         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkNodeRuleGroupForTpdrDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkNodeRuleGroupForTpdrDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,

-                                              Uuid nodeUuid) {
-        assertEquals("transponder DSR should contain 2 node rule group", 2, nrgList.size());
+            Uuid nodeUuid) {
+        assertEquals(2, nrgList.size(), "transponder DSR should contain 2 node rule group");

         for (NodeRuleGroup nodeRuleGroup : nrgList) {
         for (NodeRuleGroup nodeRuleGroup : nrgList) {

-            assertEquals("each node-rule-group should contain 2 NEP for transponder DSR",
-                2, nodeRuleGroup.getNodeEdgePoint().size());
+            assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(),
+                "each node-rule-group should contain 2 NEP for transponder DSR");

         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",


@@ -970,26 +955,24 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));

-        assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node",
-            nodeEdgePointList.get(0).getNodeUuid(), nodeUuid);
-        assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node",
-            nodeEdgePointList.get(1).getNodeUuid(), nodeUuid);
+        assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node");
+        assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node");

         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());
         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());

-        assertEquals("node-rule-group nb 1 should contain a single rule", 1, rule.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", rule.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, rule.get(0).getRuleType());
+        assertEquals(1, rule.size(), "node-rule-group nb 1 should contain a single rule");
+        assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForMuxDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
     }
 
     private void checkNodeRuleGroupForMuxDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,

-                                             Uuid nodeUuid) {
-        assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size());
+            Uuid nodeUuid) {
+        assertEquals(4, nrgList.size(), "muxponder DSR should contain 4 node rule group");

         for (NodeRuleGroup nodeRuleGroup : nrgList) {
         for (NodeRuleGroup nodeRuleGroup : nrgList) {

-            assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR",
-                2, nodeRuleGroup.getNodeEdgePoint().size());
+            assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(),
+                "each node-rule-group should contain 2 NEP for muxponder DSR");

         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(2).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(2).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",


@@ -998,122 +981,112 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));

-        assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
-            nodeEdgePointList.get(0).getNodeUuid(), nodeUuid);
-        assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
-            nodeEdgePointList.get(1).getNodeUuid(), nodeUuid);
+        assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node");
+        assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node");

         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());
         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());

-        assertEquals("node-rule-group nb 2 should contain a single rule", 1, rule.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", rule.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, rule.get(0).getRuleType());
+        assertEquals(1, rule.size(), "node-rule-group nb 2 should contain a single rule");
+        assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForSwitchDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
     }
 
     private void checkNodeRuleGroupForSwitchDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,

-                                                Uuid nodeUuid) {
-        assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size());
-        assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size());
+            Uuid nodeUuid) {
+        assertEquals(1, nrgList.size(), "Switch-DSR should contain a single node rule group");
+        assertEquals(8, nrgList.get(0).getNodeEdgePoint().size(), "Switch-DSR node-rule-group should contain 8 NEP");

         List<NodeEdgePoint> nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream()
             .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue()
                 .compareTo(nrg2.getNodeEdgePointUuid().getValue()))
             .collect(Collectors.toList());
         List<NodeEdgePoint> nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream()
             .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue()
                 .compareTo(nrg2.getNodeEdgePointUuid().getValue()))
             .collect(Collectors.toList());

-        assertEquals("in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1",
-            networkNepUuid, nrg.get(6).getNodeEdgePointUuid());
-        assertEquals("in the sorted node-rule-group, nep number 4 should be XPDR2-CLIENT4",
-            clientNepUuid, nrg.get(3).getNodeEdgePointUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nrg.get(4).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nrg.get(3).getNodeUuid());
+        assertEquals(networkNepUuid, nrg.get(6).getNodeEdgePointUuid(),
+            "in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1");
+        assertEquals(clientNepUuid, nrg.get(3).getNodeEdgePointUuid(),
+            "in the sorted node-rule-group, nep number 4 should be XPDR2-CLIENT4");
+        assertEquals(nodeUuid, nrg.get(4).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nrg.get(3).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         @Nullable
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         @Nullable
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForRdm(List<NodeRuleGroup> nrgList, int nbNeps) {
     }
 
     private void checkNodeRuleGroupForRdm(List<NodeRuleGroup> nrgList, int nbNeps) {

-        assertEquals("RDM infra node - OTSi should contain a single node rule groups", 1, nrgList.size());
+        assertEquals(1, nrgList.size(), "RDM infra node - OTSi should contain a single node rule groups");

         if (nbNeps > 0) {
             List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         if (nbNeps > 0) {
             List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-            assertEquals("RDM infra node -rule-group should contain " + nbNeps + " NEP",
-                nbNeps, nodeEdgePointList.size());
+            assertEquals(nbNeps, nodeEdgePointList.size(),
+                "RDM infra node -rule-group should contain " + nbNeps + " NEP");

         } else {
         } else {

-            assertNull("RDM infra node -rule-group should contain no NEP", nrgList.get(0).getNodeEdgePoint());
+            assertNull(nrgList.get(0).getNodeEdgePoint(), "RDM infra node -rule-group should contain no NEP");

         }
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         }
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForTpdrOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
     }
 
     private void checkNodeRuleGroupForTpdrOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,

-                                               Uuid nodeUuid) {
-        assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size());
+            Uuid nodeUuid) {
+        assertEquals(2, nrgList.size(), "Tpdr-OTSi should contain two node rule groups");

         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-        assertEquals("Tpdr-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
+        assertEquals(2, nodeEdgePointList.size(), "Tpdr-OTSi node-rule-group should contain 2 NEP");

         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));

-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(0).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(1).getNodeUuid());
+        assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForMuxOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
     }
 
     private void checkNodeRuleGroupForMuxOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,

-                                              Uuid nodeUuid) {
-        assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size());
+            Uuid nodeUuid) {
+        assertEquals(1, nrgList.size(), "Mux-OTSi should contain a single node rule group");

         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-        assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
+        assertEquals(2, nodeEdgePointList.size(), "Mux-OTSi node-rule-group should contain 2 NEP");

         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));

-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(0).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(1).getNodeUuid());
+        assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForSwitchOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
     }
 
     private void checkNodeRuleGroupForSwitchOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,

-                                                 Uuid nodeUuid) {
-        assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size());
+            Uuid nodeUuid) {
+        assertEquals(4, nrgList.size(), "Switch-OTSi should contain 4 node rule group");

         for (NodeRuleGroup nodeRuleGroup : nrgList) {
         for (NodeRuleGroup nodeRuleGroup : nrgList) {

-            assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi",
-                2, nodeRuleGroup.getNodeEdgePoint().size());
+            assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(),
+                "each node-rule-group should contain 2 NEP for Switch-OTSi");

         }
         List<NodeEdgePoint> nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values());
         assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",
         }
         List<NodeEdgePoint> nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values());
         assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",


@@ -1123,130 +1096,123 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         List<NodeEdgePoint> nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
             nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         List<NodeEdgePoint> nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList0.get(0).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList0.get(1).getNodeUuid());
+        assertEquals(nodeUuid, nodeEdgePointList0.get(0).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nodeEdgePointList0.get(1).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         List<Rule> ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         List<Rule> ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList0.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList0.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList0.get(0).getRuleType());
+        assertEquals(1, ruleList0.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList0.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList0.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
     }
 
     private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of client nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
-        assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("Client nep should support 2 kind of cep",
-            2, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(portName, nameList.get(0).getValue(),
+            "value of client nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(),
+            "value-name of client nep for '" + portName + "' should be '" + nepName + "'");
+        assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 2 kind of cep");

         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU4.VALUE, DIGITALSIGNALTYPE100GigE.VALUE));
         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU4.VALUE, DIGITALSIGNALTYPE100GigE.VALUE));

-        assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.DSR, nep.getLayerProtocolName(), "client nep should be of DSR protocol type");

         checkCommonPartOfNep(nep, false);
     }
 
     private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
         checkCommonPartOfNep(nep, false);
     }
 
     private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of client nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
-        assertEquals("value-name of client nep for '" + portName + "' should be 100G-tpdr'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("Client nep should support 1 kind of cep",
-            1, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(portName, nameList.get(0).getValue(), "value of client nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(),
+            "value-name of client nep for '" + portName + "' should be 100G-tpdr'");
+        assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 1 kind of cep");

         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(DIGITALSIGNALTYPE100GigE.VALUE));
         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(DIGITALSIGNALTYPE100GigE.VALUE));

-        assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.DSR, nep.getLayerProtocolName(), "client nep should be of DSR protocol type");

         checkCommonPartOfNep(nep, false);
     }
 
     private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
         checkCommonPartOfNep(nep, false);
     }
 
     private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,

-                                  boolean withSip) {
-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+            boolean withSip) {
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of OTSi nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
-        assertEquals("value-name of OTSi nep should be '" + nepName + "'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("OTSi nep should support 2 kind of cep",
-            2, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(portName, nameList.get(0).getValue(), "value of OTSi nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(), "value-name of OTSi nep should be '" + nepName + "'");
+        assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(),
+            "OTSi nep should support 2 kind of cep");

         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE, PHOTONICLAYERQUALIFIEROTSi.VALUE));
         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE, PHOTONICLAYERQUALIFIEROTSi.VALUE));

-        assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type",
-            LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(),
+            "OTSi nep should be of PHOTONIC_MEDIA protocol type");

         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,

-                                     boolean withSip) {
-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+            boolean withSip) {
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of OTSi nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
-        assertEquals("value-name of OTSi nep should be '" + nepName + "'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("OTSi nep of RDM infra node should support only 1 kind of cep",
-            1, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(portName, nameList.get(0).getValue(),
+            "value of OTSi nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(),
+            "value-name of OTSi nep should be '" + nepName + "'");
+        assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(),
+            "OTSi nep of RDM infra node should support only 1 kind of cep");

         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE));
         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE));

-        assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type",
-            LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(),
+            "OTSi nep should be of PHOTONIC_MEDIA protocol type");

         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkCommonPartOfNep(OwnedNodeEdgePoint nep, boolean withSip) {
         checkCommonPartOfNep(nep, withSip);
     }
 
     private void checkCommonPartOfNep(OwnedNodeEdgePoint nep, boolean withSip) {

-        assertEquals("link port direction should be DIRECTIONAL",
-            PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection());
-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, nep.getAdministrativeState());
-        assertEquals("termination state should be TERMINATED BIDIRECTIONAL",
-            TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState());
-        assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, nep.getLifecycleState());
+        assertEquals(PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection(),
+            "link port direction should be DIRECTIONAL");
+        assertEquals(AdministrativeState.UNLOCKED, nep.getAdministrativeState(),
+            "administrative state should be UNLOCKED");
+        assertEquals(TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState(),
+            "termination state should be TERMINATED BIDIRECTIONAL");
+        assertEquals(LifecycleState.INSTALLED, nep.getLifecycleState(), "life-cycle state should be INSTALLED");

         if (withSip) {
         if (withSip) {

-            assertEquals("Given nep should support 1 SIP", 1, nep.getMappedServiceInterfacePoint().size());
+            assertEquals(1, nep.getMappedServiceInterfacePoint().size(), "Given nep should support 1 SIP");

         }
         }

-        assertEquals("termination direction should be BIDIRECTIONAL",
-            TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection());
-        assertEquals("operational state of client nep should be ENABLED",
-            OperationalState.ENABLED, nep.getOperationalState());
-        assertEquals("link-port-role of client nep should be SYMMETRIC",
-            PortRole.SYMMETRIC, nep.getLinkPortRole());
+        assertEquals(TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection(),
+            "termination direction should be BIDIRECTIONAL");
+        assertEquals(OperationalState.ENABLED, nep.getOperationalState(),
+            "operational state of client nep should be ENABLED");
+        assertEquals(PortRole.SYMMETRIC, nep.getLinkPortRole(),
+            "link-port-role of client nep should be SYMMETRIC");

     }
 
     }
 

-    private void checkTransitionalLink(org.opendaylight.yang.gen.v1
-                                           .urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link,
-                                       Uuid node1Uuid, Uuid node2Uuid, String tp1, String tp2, String ietfNodeId) {
-        Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "to" + tp2)
-            .getBytes(Charset.forName("UTF-8"))).toString());
-        assertEquals("bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2, linkUuid, link.getUuid());
-        assertEquals("Available capacity unit should be GBPS",
-            CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit());
-        assertEquals("Available capacity -total size value should be 100",
-            Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue());
-        assertEquals("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
-            2, link.getTransitionedLayerProtocolName().size());
+    private void checkTransitionalLink(
+            org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link, Uuid node1Uuid,
+            Uuid node2Uuid, String tp1, String tp2, String ietfNodeId) {
+        Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "to" + tp2).getBytes(Charset.forName("UTF-8")))
+            .toString());
+        assertEquals(linkUuid, link.getUuid(), "bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2);
+        assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(),
+            "Available capacity unit should be GBPS");
+        assertEquals(Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue(),
+            "Available capacity -total size value should be 100");
+        assertEquals(2, link.getTransitionedLayerProtocolName().size(),
+            "transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA");

         assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
             link.getTransitionedLayerProtocolName(),
             hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName()));
         assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
             link.getTransitionedLayerProtocolName(),
             hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName()));

-        assertEquals("transitional link should be BIDIRECTIONAL",
-            ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+        assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(),
+            "transitional link should be BIDIRECTIONAL");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());

-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
+        assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");
+        assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");

         assertThat("transitional links should terminate on DSR node and Photonic node",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
         assertThat("transitional links should terminate on DSR node and Photonic node",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));


@@ -1263,25 +1229,22 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue())));
     }
 
             either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue())));
     }
 

-

     private void checkOmsLink(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link,
     private void checkOmsLink(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link,

-                              Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
-                              String linkName) {
-        assertEquals("bad name for the link", linkName, link.getName().get(
-            new NameKey("OMS link name")).getValue());
-        assertEquals("bad uuid for link", linkUuid, link.getUuid());
-        assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
+            Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, String linkName) {
+        assertEquals(linkName, link.getName().get(new NameKey("OMS link name")).getValue(), "bad name for the link");
+        assertEquals(linkUuid, link.getUuid(), "bad uuid for link");
+        assertEquals(

             LayerProtocolName.PHOTONICMEDIA.getName(),
             LayerProtocolName.PHOTONICMEDIA.getName(),

-            link.getLayerProtocolName().stream().findFirst().get().getName());
-        assertEquals("otn tapi link should be BIDIRECTIONAL",
-            ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+            link.getLayerProtocolName().stream().findFirst().get().getName(),
+            "oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA");
+        assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(),"otn tapi link should be BIDIRECTIONAL");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());

-        assertEquals("oms link should be between 2 neps",2 , nodeEdgePointList.size());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
+        assertEquals(2 , nodeEdgePointList.size(), "oms link should be between 2 neps");
+        assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");
+        assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");

         assertThat("oms links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
         assertThat("oms links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));


@@ -1296,25 +1259,25 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
             either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
     }
 
             either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
     }
 

-    private void checkXpdrRdmLink(org.opendaylight.yang.gen.v1.urn
-                                      .onf.otcc.yang.tapi.topology.rev181210.topology.Link link,
-                              Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
-                              String linkName) {
-        assertEquals("bad name for the link", linkName, link.getName().get(
-            new NameKey("XPDR-RDM link name")).getValue());
-        assertEquals("bad uuid for link", linkUuid, link.getUuid());
-        assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
+    private void checkXpdrRdmLink(
+            org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link, Uuid node1Uuid,
+            Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, String linkName) {
+        assertEquals(linkName, link.getName().get(new NameKey("XPDR-RDM link name")).getValue(),
+            "bad name for the link");
+        assertEquals(linkUuid, link.getUuid(), "bad uuid for link");
+        assertEquals(

             LayerProtocolName.PHOTONICMEDIA.getName(),
             LayerProtocolName.PHOTONICMEDIA.getName(),

-            link.getLayerProtocolName().stream().findFirst().get().getName());
-        assertEquals("otn tapi link should be BIDIRECTIONAL",
-            ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+            link.getLayerProtocolName().stream().findFirst().get().getName(),
+            "oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA");
+        assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(),
+            "otn tapi link should be BIDIRECTIONAL");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());

-        assertEquals("oms link should be between 2 neps",2 , nodeEdgePointList.size());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
+        assertEquals(2 , nodeEdgePointList.size(), "oms link should be between 2 neps");
+        assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");
+        assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");

         assertThat("oms links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
         assertThat("oms links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));


@@ -1352,4 +1315,4 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest {
         tpdr1Bldr.setTerminationPoint(tps);
         return new NodeBuilder(initialNode).addAugmentation(tpdr1Bldr.build()).build();
     }
         tpdr1Bldr.setTerminationPoint(tps);
         return new NodeBuilder(initialNode).addAugmentation(tpdr1Bldr.build()).build();
     }

-}
+}
\ No newline at end of file

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java
index ed2e52638de989f1f09d2bdb59f1f9bb043b3b73..001e944e0241d0a40ab37a218fe6dd6e41bd88e0 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java
@@ -12,9 +12,9 @@ import static org.hamcrest.CoreMatchers.either;
 import static org.hamcrest.CoreMatchers.hasItem;
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.CoreMatchers.hasItem;
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.MatcherAssert.assertThat;

-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.fail;

 
 import com.google.common.util.concurrent.FluentFuture;
 import java.nio.charset.Charset;
 
 import com.google.common.util.concurrent.FluentFuture;
 import java.nio.charset.Charset;


@@ -28,8 +28,8 @@ import java.util.UUID;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.Nullable;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.Nullable;

-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;

 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.transportpce.common.InstanceIdentifiers;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.transportpce.common.InstanceIdentifiers;


@@ -111,8 +111,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     private static TapiLink tapiLink;
     private static DataBroker dataBroker = getDataBroker();
 
     private static TapiLink tapiLink;
     private static DataBroker dataBroker = getDataBroker();
 

-    @BeforeClass
-    public static void setUp() throws InterruptedException, ExecutionException {
+    @BeforeAll
+    static void setUp() throws InterruptedException, ExecutionException {

         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
             TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
             TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),


@@ -167,7 +167,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeWhenNoStates() {
+    void convertNodeWhenNoStates() {

         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", null, null);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", null, null);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -187,8 +187,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));

-        assertNull("Administrative State should not be present", nepN.getAdministrativeState());
-        assertNull("Operational State should not be present", nepN.getOperationalState());
+        assertNull(nepN.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(nepN.getOperationalState(), "Operational State should not be present");

 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -202,16 +202,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));

-        assertNull("Administrative State should not be present", enep.getAdministrativeState());
-        assertNull("Operational State should not be present", enep.getOperationalState());
+        assertNull(enep.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(enep.getOperationalState(), "Operational State should not be present");

 
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
 
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));

-        assertNull("Administrative State should not be present", inep.getAdministrativeState());
-        assertNull("Operational State should not be present", inep.getOperationalState());
+        assertNull(inep.getAdministrativeState(), "Administrative State should not be present");
+        assertNull(inep.getOperationalState(), "Operational State should not be present");

     }
 
     @Test
     }
 
     @Test

-    public void convertNodeWhenBadStates1() {
+    void convertNodeWhenBadStates1() {

         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.OutOfService,
             State.OutOfService);
         List<String> networkPortList = new ArrayList<>();
         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.OutOfService,
             State.OutOfService);
         List<String> networkPortList = new ArrayList<>();


@@ -232,10 +232,9 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, nepN.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, nepN.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, nepN.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, nepN.getOperationalState(), "Operational State should be Disabled");

 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -249,20 +248,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, enep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, enep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled");

 
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
 
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, inep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, inep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled");

     }
 
     @Test
     }
 
     @Test

-    public void convertNodeWhenBadStates2() {
+    void convertNodeWhenBadStates2() {

         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.Maintenance,
             State.Degraded);
         List<String> networkPortList = new ArrayList<>();
         Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.Maintenance,
             State.Degraded);
         List<String> networkPortList = new ArrayList<>();


@@ -283,10 +280,9 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, nepN.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, nepN.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, nepN.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, nepN.getOperationalState(), "Operational State should be Disabled");

 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -300,20 +296,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
                 .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, enep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, enep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled");

 
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
 
         OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));

-        assertEquals("Administrative State should be Locked",
-            AdministrativeState.LOCKED, inep.getAdministrativeState());
-        assertEquals("Operational State should be Disabled",
-            OperationalState.DISABLED, inep.getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(),
+            "Administrative State should be Locked");
+        assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled");

     }
 
     @Test
     }
 
     @Test

-    public void convertOtnLinkWhenNoState() {
+    void convertOtnLinkWhenNoState() {

         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link


@@ -341,16 +335,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());

-        assertNull("Administrative State should not be present", tapiLinks.get(3).getAdministrativeState());
-        assertEquals("Administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState());
-        assertNull("Operational State should not be present", tapiLinks.get(3).getOperationalState());
-        assertEquals("Operational state should be ENABLED",
-            OperationalState.ENABLED, tapiLinks.get(0).getOperationalState());
+        assertNull(tapiLinks.get(3).getAdministrativeState(), "Administrative State should not be present");
+        assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(),
+            "Administrative state should be UNLOCKED");
+        assertNull(tapiLinks.get(3).getOperationalState(), "Operational State should not be present");
+        assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(),
+            "Operational state should be ENABLED");

     }
 
     @Test
     }
 
     @Test

-    public void convertOtnLinkWhenNoStateOnOppositeLink() {
+    void convertOtnLinkWhenNoStateOnOppositeLink() {

         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link


@@ -378,16 +372,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());

-        assertNull("Administrative State should not be present", tapiLinks.get(3).getAdministrativeState());
-        assertEquals("Administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState());
-        assertNull("Operational State should not be present", tapiLinks.get(3).getOperationalState());
-        assertEquals("Operational state should be ENABLED",
-            OperationalState.ENABLED, tapiLinks.get(0).getOperationalState());
+        assertNull(tapiLinks.get(3).getAdministrativeState(), "Administrative State should not be present");
+        assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(),
+            "Administrative state should be UNLOCKED");
+        assertNull(tapiLinks.get(3).getOperationalState(), "Operational State should not be present");
+        assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(),
+            "Operational state should be ENABLED");

     }
 
     @Test
     }
 
     @Test

-    public void convertOtnLinkWhenBadState1() {
+    void convertOtnLinkWhenBadState1() {

         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link


@@ -416,18 +410,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());

-        assertEquals("Administrative state should be LOCKED",
-            AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState());
-        assertEquals("Administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState());
-        assertEquals("Operational state should be DISABLED",
-            OperationalState.DISABLED, tapiLinks.get(3).getOperationalState());
-        assertEquals("Operational state should be ENABLED",
-            OperationalState.ENABLED, tapiLinks.get(0).getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState(),
+            "Administrative state should be LOCKED");
+        assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(),
+            "Administrative state should be UNLOCKED");
+        assertEquals(OperationalState.DISABLED, tapiLinks.get(3).getOperationalState(),
+            "Operational state should be DISABLED");
+        assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(),
+            "Operational state should be ENABLED");

     }
 
     @Test
     }
 
     @Test

-    public void convertOtnLinkWhenBadState2() {
+    void convertOtnLinkWhenBadState2() {

         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link


@@ -456,18 +450,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());

-        assertEquals("Administrative state should be LOCKED",
-            AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState());
-        assertEquals("Administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState());
-        assertEquals("Operational state should be DISABLED",
-            OperationalState.DISABLED, tapiLinks.get(3).getOperationalState());
-        assertEquals("Operational state should be ENABLED",
-            OperationalState.ENABLED, tapiLinks.get(0).getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState(),
+            "Administrative state should be LOCKED");
+        assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(),
+            "Administrative state should be UNLOCKED");
+        assertEquals(OperationalState.DISABLED, tapiLinks.get(3).getOperationalState(),
+            "Operational state should be DISABLED");
+        assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(),
+            "Operational state should be ENABLED");

     }
 
     @Test
     }
 
     @Test

-    public void convertOtnLinkWhenBadStateOnOppositeLink() {
+    void convertOtnLinkWhenBadStateOnOppositeLink() {

         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
         HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
             .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link


@@ -496,18 +490,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());

-        assertEquals("Administrative state should be LOCKED",
-            AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState());
-        assertEquals("Administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState());
-        assertEquals("Operational state should be DISABLED",
-            OperationalState.DISABLED, tapiLinks.get(3).getOperationalState());
-        assertEquals("Operational state should be ENABLED",
-            OperationalState.ENABLED, tapiLinks.get(0).getOperationalState());
+        assertEquals(AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState(),
+            "Administrative state should be LOCKED");
+        assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(),
+            "Administrative state should be UNLOCKED");
+        assertEquals(OperationalState.DISABLED, tapiLinks.get(3).getOperationalState(),
+            "Operational state should be DISABLED");
+        assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(),
+            "Operational state should be ENABLED");

     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForTransponder100G() {
+    void convertNodeForTransponder100G() {

         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -521,8 +515,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 

-        assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size());
+        assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2");
+        assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2");

 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -539,7 +533,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForOtnMuxponder() {
+    void convertNodeForOtnMuxponder() {

         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -553,8 +547,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 

-        assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size());
+        assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2");
+        assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1");

         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
         checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1+DSR");
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
         checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1+DSR");


@@ -570,7 +564,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertNodeForOtnSwitch() {
+    void convertNodeForOtnSwitch() {

         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortList = new ArrayList<>();
         for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -584,8 +578,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
             .collect(Collectors.toList());
 

-        assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size());
+        assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2");
+        assertEquals(4, tapiFactory.getTapiLinks().size(), "Link list size should be 4");

 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -602,7 +596,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertOtnLink() {
+    void convertOtnLink() {

         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortListA = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortListA = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -619,7 +613,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         }
         tapiFactory.convertNode(otnMuxC, networkPortListC);
         tapiFactory.convertLinks(otnLinks);
         }
         tapiFactory.convertNode(otnMuxC, networkPortListC);
         tapiFactory.convertLinks(otnLinks);

-        assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size());
+        assertEquals(4, tapiFactory.getTapiLinks().size(), "Link list size should be 4");

 
         Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
 
         Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());


@@ -654,12 +648,12 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertRoadmInfrastructureWhenNoXponderAttached() {
+    void convertRoadmInfrastructureWhenNoXponderAttached() {

         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         tapiFactory.convertRoadmInfrastructure();
 
         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         tapiFactory.convertRoadmInfrastructure();
 

-        assertEquals("Node list size should be 1", 1, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be empty", 0, tapiFactory.getTapiLinks().size());
+        assertEquals(1, tapiFactory.getTapiNodes().size(), "Node list size should be 1");
+        assertEquals(0, tapiFactory.getTapiLinks().size(), "Link list size should be empty");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList());
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-infra".getBytes(Charset.forName("UTF-8")))
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList());
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-infra".getBytes(Charset.forName("UTF-8")))


@@ -668,7 +662,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void convertRoadmInfrastructureWhenOtnMuxAttached() {
+    void convertRoadmInfrastructureWhenOtnMuxAttached() {

         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortListA = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
         ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink);
         List<String> networkPortListA = new ArrayList<>();
         for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {


@@ -679,8 +673,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         tapiFactory.convertNode(otnMuxA, networkPortListA);
         tapiFactory.convertRoadmInfrastructure();
 
         tapiFactory.convertNode(otnMuxA, networkPortListA);
         tapiFactory.convertRoadmInfrastructure();
 

-        assertEquals("Node list size should be 3", 3, tapiFactory.getTapiNodes().size());
-        assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size());
+        assertEquals(3, tapiFactory.getTapiNodes().size(), "Node list size should be 3");
+        assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream()
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream()
             .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))


@@ -710,16 +704,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
 
     private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
                               Uuid nodeUuid, String dsrNodeType, String nodeId) {
 
     private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
                               Uuid nodeUuid, String dsrNodeType, String nodeId) {

-        assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
-        assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("dsr/odu node name")).getValue());
-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, node.getAdministrativeState());
-        assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
-        assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
+        assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid");
+        assertEquals(nodeId, node.getName().get(new NameKey("dsr/odu node name")).getValue(), "incorrect node name");
+        assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(),
+            "administrative state should be UNLOCKED");
+        assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED");
+        assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED");

         assertThat("one value-name should be 'dsr/odu node name'",
             new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("dsr/odu node name")));
         assertThat("one value-name should be 'dsr/odu node name'",
             new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("dsr/odu node name")));

-        assertEquals("dsr node should manage 2 protocol layers : dsr and odu",
-            2, node.getLayerProtocolName().size());
+        assertEquals(2, node.getLayerProtocolName().size(),
+            "dsr node should manage 2 protocol layers : dsr and odu");

         assertThat("dsr node should manage 2 protocol layers : dsr and odu",
             node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU));
         List<OwnedNodeEdgePoint> nepsN = node.nonnullOwnedNodeEdgePoint().values().stream()
         assertThat("dsr node should manage 2 protocol layers : dsr and odu",
             node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU));
         List<OwnedNodeEdgePoint> nepsN = node.nonnullOwnedNodeEdgePoint().values().stream()


@@ -733,8 +727,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                     .collect(Collectors.toList());
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
                     .collect(Collectors.toList());

-                assertEquals("Switch-DSR node should have 4 NEPs network", 4, nepsN.size());
-                assertEquals("Switch-DSR node should have 4 NEPs client", 4, nepsC.size());
+                assertEquals(4, nepsN.size(), "Switch-DSR node should have 4 NEPs network");
+                assertEquals(4, nepsC.size(), "Switch-DSR node should have 4 NEPs client");

                 OwnedNodeEdgePoint nep1 = nepsC.get(2);
                 Uuid client4NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR2-CLIENT4")
                 OwnedNodeEdgePoint nep1 = nepsC.get(2);
                 Uuid client4NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR2-CLIENT4")


@@ -757,8 +751,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep3, nep4) -> nep3.getUuid().getValue().compareTo(nep4.getUuid().getValue()))
                     .collect(Collectors.toList());
                     .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
                     .sorted((nep3, nep4) -> nep3.getUuid().getValue().compareTo(nep4.getUuid().getValue()))
                     .collect(Collectors.toList());

-                assertEquals("Mux-DSR node should have 1 NEP network", 1, nepsN.size());
-                assertEquals("Mux-DSR node should have 4 NEPs client", 4, nepsC.size());
+                assertEquals(1, nepsN.size(), "Mux-DSR node should have 1 NEP network");
+                assertEquals(4, nepsC.size(), "Mux-DSR node should have 4 NEPs client");

                 OwnedNodeEdgePoint nep3 = nepsC.get(2);
                 Uuid client3NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT3")
                 OwnedNodeEdgePoint nep3 = nepsC.get(2);
                 Uuid client3NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT3")


@@ -782,8 +776,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                     .filter(n -> n.getName().containsKey(new NameKey("100G-tpdr")))
                     .sorted((nep5, nep6) -> nep5.getUuid().getValue().compareTo(nep6.getUuid().getValue()))
                     .collect(Collectors.toList());
                     .filter(n -> n.getName().containsKey(new NameKey("100G-tpdr")))
                     .sorted((nep5, nep6) -> nep5.getUuid().getValue().compareTo(nep6.getUuid().getValue()))
                     .collect(Collectors.toList());

-                assertEquals("Tpdr-DSR node should have 2 NEPs network", 2, nepsN.size());
-                assertEquals("Tpdr-DSR node should have 2 NEPs client", 2, nepsC.size());
+                assertEquals(2, nepsN.size(), "Tpdr-DSR node should have 2 NEPs network");
+                assertEquals(2, nepsC.size(), "Tpdr-DSR node should have 2 NEPs client");

                 OwnedNodeEdgePoint nep5 = nepsC.get(0);
                 Uuid client1NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT1")
                 OwnedNodeEdgePoint nep5 = nepsC.get(0);
                 Uuid client1NepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT1")


@@ -811,19 +805,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     private void checkOtsiNode(
         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
         Uuid nodeUuid, String otsiNodeType, String nodeId) {
     private void checkOtsiNode(
         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
         Uuid nodeUuid, String otsiNodeType, String nodeId) {

-        assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
-        assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("otsi node name")).getValue());
-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, node.getAdministrativeState());
-        assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
-        assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
+        assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid");
+        assertEquals(nodeId, node.getName().get(new NameKey("otsi node name")).getValue(), "incorrect node name");
+        assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(),
+            "administrative state should be UNLOCKED");
+        assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED");
+        assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED");

         assertThat("one value-name should be 'dsr/odu node name'",
             new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("otsi node name")));
         assertThat("one value-name should be 'dsr/odu node name'",
             new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("otsi node name")));

-        assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
-            1, node.getLayerProtocolName().size());
-        assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
-            LayerProtocolName.PHOTONICMEDIA,
-            node.getLayerProtocolName().stream().findFirst().get());
+        assertEquals(1, node.getLayerProtocolName().size(),
+            "otsi node should manage a single protocol layer : PHOTONIC_MEDIA");
+        assertEquals(LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().stream().findFirst().get(),
+            "otsi node should manage a single protocol layer : PHOTONIC_MEDIA");

         List<OwnedNodeEdgePoint> nepsI = node.nonnullOwnedNodeEdgePoint().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("iNodeEdgePoint")))
             .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
         List<OwnedNodeEdgePoint> nepsI = node.nonnullOwnedNodeEdgePoint().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("iNodeEdgePoint")))
             .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))


@@ -834,8 +827,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             .collect(Collectors.toList());
         switch (otsiNodeType) {
             case "switch":
             .collect(Collectors.toList());
         switch (otsiNodeType) {
             case "switch":

-                assertEquals("Switch-OTSi node should have 4 eNEPs", 4, nepsE.size());
-                assertEquals("Switch-OTSi node should have 4 iNEPs", 4, nepsI.size());
+                assertEquals(4, nepsE.size(), "Switch-OTSi node should have 4 eNEPs");
+                assertEquals(4, nepsI.size(), "Switch-OTSi node should have 4 iNEPs");

                 OwnedNodeEdgePoint nep1 = nepsI.get(1);
                 Uuid inepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iOTSi+XPDR2-NETWORK2")
                 OwnedNodeEdgePoint nep1 = nepsI.get(1);
                 Uuid inepUuid = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iOTSi+XPDR2-NETWORK2")


@@ -854,8 +847,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid);
                 break;
             case "mux":
                 checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid);
                 break;
             case "mux":

-                assertEquals("Mux-OTSi node should have 1 eNEP", 1, nepsE.size());
-                assertEquals("Mux-OTSi node should have 1 iNEPs", 1, nepsI.size());
+                assertEquals(1, nepsE.size(), "Mux-OTSi node should have 1 eNEP");
+                assertEquals(1, nepsI.size(), "Mux-OTSi node should have 1 iNEPs");

                 OwnedNodeEdgePoint nep3 = nepsE.get(0);
                 Uuid enepUuid2 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1")
                 OwnedNodeEdgePoint nep3 = nepsE.get(0);
                 Uuid enepUuid2 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1")


@@ -874,8 +867,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 checkNodeRuleGroupForMuxOTSi(nrgList2, enepUuid2, inepUuid2, nodeUuid);
                 break;
             case "tpdr":
                 checkNodeRuleGroupForMuxOTSi(nrgList2, enepUuid2, inepUuid2, nodeUuid);
                 break;
             case "tpdr":

-                assertEquals("Tpdr-OTSi node should have 2 eNEPs", 2, nepsE.size());
-                assertEquals("Tpdr-OTSi node should have 2 iNEPs", 2, nepsI.size());
+                assertEquals(2, nepsE.size(), "Tpdr-OTSi node should have 2 eNEPs");
+                assertEquals(2, nepsI.size(), "Tpdr-OTSi node should have 2 iNEPs");

                 OwnedNodeEdgePoint nep5 = nepsE.get(0);
                 Uuid enepUuid3 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1")
                 OwnedNodeEdgePoint nep5 = nepsE.get(0);
                 Uuid enepUuid3 = new Uuid(
                     UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1")


@@ -915,48 +908,48 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
 
     private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                    String nodeId, String extension) {
 
     private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                    String nodeId, String extension) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);

-        assertEquals("value of client nep should be '" + portName + "'",
-            String.join("+", nodeId, extension, portName), name.getValue());
-        assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
-            nepName, name.getValueName());
-        assertEquals("Client nep should support 3 kind of cep",
-            3, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(String.join("+", nodeId, extension, portName), name.getValue(),
+            "value of client nep should be '" + portName + "'");
+        assertEquals(nepName, name.getValueName(),
+            "value-name of client nep for '" + portName + "' should be '" + nepName + "'");
+        assertEquals(3, nep.getSupportedCepLayerProtocolQualifier().size(),
+            "Client nep should support 3 kind of cep");

         assertThat("client nep should support 3 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU2.VALUE, ODUTYPEODU2E.VALUE, DIGITALSIGNALTYPE10GigELAN.VALUE));
         assertThat("client nep should support 3 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU2.VALUE, ODUTYPEODU2E.VALUE, DIGITALSIGNALTYPE10GigELAN.VALUE));

-        assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.ETH, nep.getLayerProtocolName(), "client nep should be of ETH protocol type");

         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                      String nodeId, String extension) {
         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                      String nodeId, String extension) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);

-        assertEquals("value of network nep should be '" + portName + "'",
-            String.join("+", nodeId, extension, portName), name.getValue());
-        assertEquals("value-name of network nep for '" + portName + "' should be '" + nepName + "'",
-            nepName, name.getValueName());
-        assertEquals("Network nep should support 1 kind of cep",
-            1, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(String.join("+", nodeId, extension, portName), name.getValue(),
+            "value of network nep should be '" + portName + "'");
+        assertEquals(nepName, name.getValueName(),
+            "value-name of network nep for '" + portName + "' should be '" + nepName + "'");
+        assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(),
+            "Network nep should support 1 kind of cep");

         assertThat("network nep should support 1 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItem(ODUTYPEODU4.VALUE));
         assertThat("network nep should support 1 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItem(ODUTYPEODU4.VALUE));

-        assertEquals("network nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.ODU, nep.getLayerProtocolName(), "network nep should be of ODU protocol type");

         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNodeRuleGroupForTpdrDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
                                               Uuid nodeUuid) {
         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNodeRuleGroupForTpdrDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
                                               Uuid nodeUuid) {

-        assertEquals("transponder DSR should contain 2 node rule group", 2, nrgList.size());
+        assertEquals(2, nrgList.size(), "transponder DSR should contain 2 node rule group");

         for (NodeRuleGroup nodeRuleGroup : nrgList) {
         for (NodeRuleGroup nodeRuleGroup : nrgList) {

-            assertEquals("each node-rule-group should contain 2 NEP for transponder DSR",
-                2, nodeRuleGroup.getNodeEdgePoint().size());
+            assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(),
+                "each node-rule-group should contain 2 NEP for transponder DSR");

         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",


@@ -965,26 +958,24 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
         assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));

-        assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node",
-            nodeEdgePointList.get(0).getNodeUuid(), nodeUuid);
-        assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node",
-            nodeEdgePointList.get(1).getNodeUuid(), nodeUuid);
+        assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node");
+        assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node");

         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());
         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());

-        assertEquals("node-rule-group nb 1 should contain a single rule", 1, rule.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", rule.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, rule.get(0).getRuleType());
+        assertEquals(1, rule.size(), "node-rule-group nb 1 should contain a single rule");
+        assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForMuxDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
                                              Uuid nodeUuid) {
     }
 
     private void checkNodeRuleGroupForMuxDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
                                              Uuid nodeUuid) {

-        assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size());
+        assertEquals(4, nrgList.size(), "muxponder DSR should contain 4 node rule group");

         for (NodeRuleGroup nodeRuleGroup : nrgList) {
         for (NodeRuleGroup nodeRuleGroup : nrgList) {

-            assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR",
-                2, nodeRuleGroup.getNodeEdgePoint().size());
+            assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(),
+                "each node-rule-group should contain 2 NEP for muxponder DSR");

         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
         }
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",


@@ -993,122 +984,112 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
         assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));

-        assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
-            nodeEdgePointList.get(0).getNodeUuid(), nodeUuid);
-        assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
-            nodeEdgePointList.get(1).getNodeUuid(), nodeUuid);
+        assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node");
+        assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid,
+            "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node");

         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());
         List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());

-        assertEquals("node-rule-group nb 2 should contain a single rule", 1, rule.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", rule.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, rule.get(0).getRuleType());
+        assertEquals(1, rule.size(), "node-rule-group nb 2 should contain a single rule");
+        assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForSwitchDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
                                                 Uuid nodeUuid) {
     }
 
     private void checkNodeRuleGroupForSwitchDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
                                                 Uuid nodeUuid) {

-        assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size());
-        assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size());
+        assertEquals(1, nrgList.size(), "Switch-DSR should contain a single node rule group");
+        assertEquals(8, nrgList.get(0).getNodeEdgePoint().size(), "Switch-DSR node-rule-group should contain 8 NEP");

         List<NodeEdgePoint> nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream()
             .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue()
                 .compareTo(nrg2.getNodeEdgePointUuid().getValue()))
             .collect(Collectors.toList());
         List<NodeEdgePoint> nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream()
             .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue()
                 .compareTo(nrg2.getNodeEdgePointUuid().getValue()))
             .collect(Collectors.toList());

-        assertEquals("in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1",
-            networkNepUuid, nrg.get(6).getNodeEdgePointUuid());
-        assertEquals("in the sorted node-rule-group, nep number 6 should be XPDR2-CLIENT4",
-            clientNepUuid, nrg.get(5).getNodeEdgePointUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nrg.get(4).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nrg.get(3).getNodeUuid());
+        assertEquals(networkNepUuid, nrg.get(6).getNodeEdgePointUuid(),
+            "in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1");
+        assertEquals(clientNepUuid, nrg.get(5).getNodeEdgePointUuid(),
+            "in the sorted node-rule-group, nep number 6 should be XPDR2-CLIENT4");
+        assertEquals(nodeUuid, nrg.get(4).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nrg.get(3).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         @Nullable
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         @Nullable
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForRdmInfra(List<NodeRuleGroup> nrgList, int nbNeps) {
     }
 
     private void checkNodeRuleGroupForRdmInfra(List<NodeRuleGroup> nrgList, int nbNeps) {

-        assertEquals("RDM infra node - OTSi should contain a single node rule groups", 1, nrgList.size());
+        assertEquals(1, nrgList.size(), "RDM infra node - OTSi should contain a single node rule groups");

         if (nbNeps > 0) {
             List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         if (nbNeps > 0) {
             List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-            assertEquals("RDM infra node -rule-group should contain " + nbNeps + " NEP",
-                nbNeps, nodeEdgePointList.size());
+            assertEquals(nbNeps, nodeEdgePointList.size(),
+                "RDM infra node -rule-group should contain " + nbNeps + " NEP");

         } else {
         } else {

-            assertNull("RDM infra node -rule-group should contain no NEP", nrgList.get(0).getNodeEdgePoint());
+            assertNull(nrgList.get(0).getNodeEdgePoint(), "RDM infra node -rule-group should contain no NEP");

         }
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         }
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForTpdrOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
                                                Uuid nodeUuid) {
     }
 
     private void checkNodeRuleGroupForTpdrOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
                                                Uuid nodeUuid) {

-        assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size());
+        assertEquals(2, nrgList.size(), "Tpdr-OTSi should contain two node rule groups");

         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-        assertEquals("Tpdr-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
+        assertEquals(2, nodeEdgePointList.size(), "Tpdr-OTSi node-rule-group should contain 2 NEP");

         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));

-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(0).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(1).getNodeUuid());
+        assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForMuxOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
                                               Uuid nodeUuid) {
     }
 
     private void checkNodeRuleGroupForMuxOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
                                               Uuid nodeUuid) {

-        assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size());
+        assertEquals(1, nrgList.size(), "Mux-OTSi should contain a single node rule group");

         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-        assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
+        assertEquals(2, nodeEdgePointList.size(), "Mux-OTSi node-rule-group should contain 2 NEP");

         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));

-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(0).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList.get(1).getNodeUuid());
+        assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNodeRuleGroupForSwitchOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
                                                  Uuid nodeUuid) {
     }
 
     private void checkNodeRuleGroupForSwitchOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
                                                  Uuid nodeUuid) {

-        assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size());
+        assertEquals(4, nrgList.size(), "Switch-OTSi should contain 4 node rule group");

         for (NodeRuleGroup nodeRuleGroup : nrgList) {
         for (NodeRuleGroup nodeRuleGroup : nrgList) {

-            assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi",
-                2, nodeRuleGroup.getNodeEdgePoint().size());
+            assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(),
+                "each node-rule-group should contain 2 NEP for Switch-OTSi");

         }
         List<NodeEdgePoint> nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values());
         assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",
         }
         List<NodeEdgePoint> nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values());
         assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",


@@ -1118,72 +1099,66 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         List<NodeEdgePoint> nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
             nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
         List<NodeEdgePoint> nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList0.get(0).getNodeUuid());
-        assertEquals("any item of the node-rule-group should have the same nodeUuid",
-            nodeUuid, nodeEdgePointList0.get(1).getNodeUuid());
+        assertEquals(nodeUuid, nodeEdgePointList0.get(0).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");
+        assertEquals(nodeUuid, nodeEdgePointList0.get(1).getNodeUuid(),
+            "any item of the node-rule-group should have the same nodeUuid");

         List<Rule> ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         List<Rule> ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList0.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList0.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList0.get(0).getRuleType());
+        assertEquals(1, ruleList0.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList0.get(0).getLocalId(),"local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList0.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                           String nodeId, String extension) {
     }
 
     private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                           String nodeId, String extension) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of client nep should be '" + portName + "'",
-            String.join("+", nodeId, extension, portName), nameList.get(0).getValue());
-        assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("Client nep should support 2 kind of cep",
-            2, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(String.join("+", nodeId, extension, portName), nameList.get(0).getValue(),
+            "value of client nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(),
+            "value-name of client nep for '" + portName + "' should be '" + nepName + "'");
+        assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 2 kind of cep");

         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU4.VALUE, DIGITALSIGNALTYPE100GigE.VALUE));
         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(ODUTYPEODU4.VALUE, DIGITALSIGNALTYPE100GigE.VALUE));

-        assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.ETH, nep.getLayerProtocolName(), "client nep should be of ETH protocol type");

         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                         String nodeId, String extension) {
         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                         String nodeId, String extension) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of client nep should be '" + portName + "'",
-            String.join("+", nodeId, extension, portName), nameList.get(0).getValue());
-        assertEquals("value-name of client nep for '" + portName + "' should be 100G-tpdr'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("Client nep should support 1 kind of cep",
-            1, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(String.join("+", nodeId, extension, portName), nameList.get(0).getValue(),
+            "value of client nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(),
+            "value-name of client nep for '" + portName + "' should be 100G-tpdr'");
+        assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 1 kind of cep");

         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(DIGITALSIGNALTYPE100GigE.VALUE));
         assertThat("client nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(DIGITALSIGNALTYPE100GigE.VALUE));

-        assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName());
+        assertEquals(LayerProtocolName.ETH, nep.getLayerProtocolName(), "client nep should be of ETH protocol type");

         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                   String nodeId, String extension) {
         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
 
     private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
                                   String nodeId, String extension) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of OTSi nep should be '" + portName + "'",
-            String.join("+", nodeId, extension, portName), nameList.get(0).getValue());
-        assertEquals("value-name of OTSi nep should be '" + nepName + "'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("OTSi nep should support 2 kind of cep",
-            2, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(String.join("+", nodeId, extension, portName), nameList.get(0).getValue(),
+            "value of OTSi nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(), "value-name of OTSi nep should be '" + nepName + "'");
+        assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(), "OTSi nep should support 2 kind of cep");

         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE, PHOTONICLAYERQUALIFIEROTSi.VALUE));
         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE, PHOTONICLAYERQUALIFIEROTSi.VALUE));

-        assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type",
-            LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName());
-        assertEquals("OTSi nep should support one SIP", 1, nep.getMappedServiceInterfacePoint().size());
+        assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(),
+            "OTSi nep should be of PHOTONIC_MEDIA protocol type");
+        assertEquals(1, nep.getMappedServiceInterfacePoint().size(), "OTSi nep should support one SIP");

         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }
         checkCommonPartOfNep(nep, false);
         checkSIP(nep, portName, nodeId, extension);
     }


@@ -1191,70 +1166,71 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     private void checkSIP(OwnedNodeEdgePoint nep, String portName, String nodeId, String extension) {
         Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", nodeId, extension, portName))
             .getBytes(Charset.forName("UTF-8"))).toString());
     private void checkSIP(OwnedNodeEdgePoint nep, String portName, String nodeId, String extension) {
         Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", nodeId, extension, portName))
             .getBytes(Charset.forName("UTF-8"))).toString());

-        assertEquals("service-interface-point-uuid of network nep for '" + portName + "' should be '"
-            + String.join("+", "SIP", portName) + "'", sipUuid, nep.getMappedServiceInterfacePoint()
-            .get(new MappedServiceInterfacePointKey(sipUuid)).getServiceInterfacePointUuid());
+        assertEquals(
+            sipUuid,
+            nep.getMappedServiceInterfacePoint().get(new MappedServiceInterfacePointKey(sipUuid))
+                .getServiceInterfacePointUuid(),
+            "service-interface-point-uuid of network nep for '" + portName + "' should be '"
+                + String.join("+", "SIP", portName) + "'");

     }
 
     private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
     }
 
     private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {

-        assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
+        assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName);

         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());

-        assertEquals("value of OTSi nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
-        assertEquals("value-name of OTSi nep should be '" + nepName + "'",
-            nepName, nameList.get(0).getValueName());
-        assertEquals("OTSi nep of RDM infra node should support only 1 kind of cep",
-            1, nep.getSupportedCepLayerProtocolQualifier().size());
+        assertEquals(portName, nameList.get(0).getValue(), "value of OTSi nep should be '" + portName + "'");
+        assertEquals(nepName, nameList.get(0).getValueName(), "value-name of OTSi nep should be '" + nepName + "'");
+        assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(),
+            "OTSi nep of RDM infra node should support only 1 kind of cep");

         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE));
         assertThat("OTSi nep should support 2 kind of cep",
             nep.getSupportedCepLayerProtocolQualifier(),
             hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE));

-        assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type",
-            LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName());
-        assertEquals("OTSi nep of RDM infra should support no SIP", 0, nep.nonnullMappedServiceInterfacePoint().size());
+        assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(),
+            "OTSi nep should be of PHOTONIC_MEDIA protocol type");
+        assertEquals(0, nep.nonnullMappedServiceInterfacePoint().size(), "OTSi nep of RDM infra should support no SIP");

         checkCommonPartOfNep(nep, true);
     }
 
     private void checkCommonPartOfNep(OwnedNodeEdgePoint nep, boolean isRdm) {
         checkCommonPartOfNep(nep, true);
     }
 
     private void checkCommonPartOfNep(OwnedNodeEdgePoint nep, boolean isRdm) {

-        assertEquals("link port direction should be DIRECTIONAL",
-            PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection());
-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, nep.getAdministrativeState());
-        assertEquals("termination state should be TERMINATED BIDIRECTIONAL",
-            TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState());
-        assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, nep.getLifecycleState());
+        assertEquals(PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection(),
+            "link port direction should be DIRECTIONAL");
+        assertEquals(AdministrativeState.UNLOCKED, nep.getAdministrativeState(),
+            "administrative state should be UNLOCKED");
+        assertEquals(TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState(),
+            "termination state should be TERMINATED BIDIRECTIONAL");
+        assertEquals(LifecycleState.INSTALLED, nep.getLifecycleState(),
+            "life-cycle state should be INSTALLED");

         if (!isRdm) {
         if (!isRdm) {

-            assertEquals("client nep should support 1 SIP", 1, nep.getMappedServiceInterfacePoint().size());
+            assertEquals(1, nep.getMappedServiceInterfacePoint().size(), "client nep should support 1 SIP");

         }
         }

-        assertEquals("termination direction should be BIDIRECTIONAL",
-            TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection());
-        assertEquals("operational state of client nep should be ENABLED",
-            OperationalState.ENABLED, nep.getOperationalState());
-        assertEquals("link-port-role of client nep should be SYMMETRIC",
-            PortRole.SYMMETRIC, nep.getLinkPortRole());
+        assertEquals(TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection(),
+            "termination direction should be BIDIRECTIONAL");
+        assertEquals(OperationalState.ENABLED, nep.getOperationalState(),
+            "operational state of client nep should be ENABLED");
+        assertEquals(PortRole.SYMMETRIC, nep.getLinkPortRole(), "link-port-role of client nep should be SYMMETRIC");

     }
 
     private void checkTransitionalLink(Link link, Uuid node1Uuid, Uuid node2Uuid, String tp1, String tp2,
                                        String ietfNodeId) {
         Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "to" + tp2)
             .getBytes(Charset.forName("UTF-8"))).toString());
     }
 
     private void checkTransitionalLink(Link link, Uuid node1Uuid, Uuid node2Uuid, String tp1, String tp2,
                                        String ietfNodeId) {
         Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "to" + tp2)
             .getBytes(Charset.forName("UTF-8"))).toString());

-        assertEquals("bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2, linkUuid, link.getUuid());
-        assertEquals("Available capacity unit should be GBPS",
-            CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit());
-        assertEquals("Available capacity -total size value should be 100",
-            Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue());
-        assertEquals("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
-            2, link.getTransitionedLayerProtocolName().size());
+        assertEquals(linkUuid, link.getUuid(), "bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2);
+        assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(),
+            "Available capacity unit should be GBPS");
+        assertEquals(Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue(),
+            "Available capacity -total size value should be 100");
+        assertEquals(2, link.getTransitionedLayerProtocolName().size(),
+            "transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA");

         assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
             link.getTransitionedLayerProtocolName(),
             hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName()));
         assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
             link.getTransitionedLayerProtocolName(),
             hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName()));

-        assertEquals("transitional link should be BIDIRECTIONAL",
-            ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+        assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(),
+            "transitional link should be BIDIRECTIONAL");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());

-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
+        assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");
+        assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");

         assertThat("transitional links should terminate on DSR node and Photonic node",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
         assertThat("transitional links should terminate on DSR node and Photonic node",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));


@@ -1273,39 +1249,40 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
 
     private void checkOtnLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
                               String linkName) {
 
     private void checkOtnLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
                               String linkName) {

-        assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("otn link name")).getValue());
-        assertEquals("bad uuid for link", linkUuid, link.getUuid());
-        assertEquals("Available capacity unit should be MBPS",
-            CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit());
+        assertEquals(linkName, link.getName().get(new NameKey("otn link name")).getValue(), "bad name for the link");
+        assertEquals(linkUuid, link.getUuid(), "bad uuid for link");
+        assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(),
+            "Available capacity unit should be MBPS");

         String prefix = linkName.split("-")[0];
         if ("OTU4".equals(prefix)) {
         String prefix = linkName.split("-")[0];
         if ("OTU4".equals(prefix)) {

-            assertEquals("Available capacity -total size value should be 0",
-                Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue());
+            assertEquals(Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue(),
+                "Available capacity -total size value should be 0");

         } else if ("ODTU4".equals(prefix)) {
         } else if ("ODTU4".equals(prefix)) {

-            assertEquals("Available capacity -total size value should be 100 000",
-                Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue());
+            assertEquals(Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue(),
+                "Available capacity -total size value should be 100 000");

         }
         }

-        assertEquals("Total capacity unit should be GBPS",
-            CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit());
-        assertEquals("Total capacity -total size value should be 100",
-            Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue());
+        assertEquals(CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit(),
+            "Total capacity unit should be GBPS");
+        assertEquals(Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue(),
+            "Total capacity -total size value should be 100");

         if ("OTU4".equals(prefix)) {
         if ("OTU4".equals(prefix)) {

-            assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
+            assertEquals(

                 LayerProtocolName.PHOTONICMEDIA.getName(),
                 LayerProtocolName.PHOTONICMEDIA.getName(),

-                link.getLayerProtocolName().stream().findFirst().get().getName());
+                link.getLayerProtocolName().stream().findFirst().get().getName(),
+                "otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA");

         } else if ("ODTU4".equals(prefix)) {
         } else if ("ODTU4".equals(prefix)) {

-            assertEquals("otn link should be between 2 nodes of protocol layers ODU",
+            assertEquals(

                 LayerProtocolName.ODU.getName(),
                 LayerProtocolName.ODU.getName(),

-                link.getLayerProtocolName().stream().findFirst().get().getName());
+                link.getLayerProtocolName().stream().findFirst().get().getName(),
+                "otn link should be between 2 nodes of protocol layers ODU");

         }
         }

-        assertEquals("otn tapi link should be BIDIRECTIONAL",
-            ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+        assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), "otn tapi link should be BIDIRECTIONAL");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());

-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
+        assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");
+        assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");

         assertThat("otn links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
         assertThat("otn links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));


@@ -1318,28 +1295,27 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         assertThat("otn links should terminate on two distinct tps",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
         assertThat("otn links should terminate on two distinct tps",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));

-        assertEquals("operational state should be ENABLED",
-            OperationalState.ENABLED, link.getOperationalState());
-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, link.getAdministrativeState());
+        assertEquals(OperationalState.ENABLED, link.getOperationalState(), "operational state should be ENABLED");
+        assertEquals(AdministrativeState.UNLOCKED, link.getAdministrativeState(),
+            "administrative state should be UNLOCKED");

     }
 
     private void checkOmsLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
                               String linkName) {
     }
 
     private void checkOmsLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
                               String linkName) {

-        assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("OMS link name")).getValue());
-        assertEquals("bad uuid for link", linkUuid, link.getUuid());
-        assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
+        assertEquals(linkName, link.getName().get(new NameKey("OMS link name")).getValue(), "bad name for the link");
+        assertEquals(linkUuid, link.getUuid(), "bad uuid for link");
+        assertEquals(

             LayerProtocolName.PHOTONICMEDIA.getName(),
             LayerProtocolName.PHOTONICMEDIA.getName(),

-            link.getLayerProtocolName().stream().findFirst().get().getName());
-        assertEquals("otn tapi link should be BIDIRECTIONAL",
-            ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+            link.getLayerProtocolName().stream().findFirst().get().getName(),
+            "oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA");
+        assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), "otn tapi link should be BIDIRECTIONAL");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());

-        assertEquals("oms link should be between 2 neps",2 , nodeEdgePointList.size());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
+        assertEquals(2, nodeEdgePointList.size(), "oms link should be between 2 neps");
+        assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");
+        assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");

         assertThat("oms links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
         assertThat("oms links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java
index 9f4f466e73e0ed9a37fe76e736cb3dcc3ab090e2..31556e8c5a235be8c051e076fe84b0bd386e4455 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java
@@ -7,7 +7,7 @@
  */
 package org.opendaylight.transportpce.tapi.topology;
 
  */
 package org.opendaylight.transportpce.tapi.topology;
 

-import static org.junit.Assert.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNull;

 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 


@@ -17,7 +17,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import org.eclipse.jdt.annotation.NonNull;
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import org.eclipse.jdt.annotation.NonNull;

-import org.junit.Test;
+import org.junit.jupiter.api.Test;

 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;


@@ -39,14 +39,14 @@ import org.opendaylight.yangtools.yang.common.RpcResult;
 
 public class TapiTopologyImplExceptionTest {
     @Mock
 
 public class TapiTopologyImplExceptionTest {
     @Mock

-    TapiContext tapiContext;
+    private TapiContext tapiContext;

     @Mock
     @Mock

-    TopologyUtils topologyUtils;
+    private TopologyUtils topologyUtils;

     @Mock
     @Mock

-    TapiLink tapiLink;
+    private TapiLink tapiLink;

 
     @Test
 
     @Test

-    public void getTopologyDetailsWithExceptionTest() throws InterruptedException, ExecutionException {
+    void getTopologyDetailsWithExceptionTest() throws InterruptedException, ExecutionException {

         DataBroker dataBroker = mock(DataBroker.class);
         when(dataBroker.newReadOnlyTransaction())
                 .thenReturn(new ReadTransactionMock());
         DataBroker dataBroker = mock(DataBroker.class);
         when(dataBroker.newReadOnlyTransaction())
                 .thenReturn(new ReadTransactionMock());


@@ -70,9 +70,9 @@ public class TapiTopologyImplExceptionTest {
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         if (rpcResult.isSuccessful()) {
             Topology topology = rpcResult.getResult().getTopology();
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         if (rpcResult.isSuccessful()) {
             Topology topology = rpcResult.getResult().getTopology();

-            assertNull("Topology should be null", topology);
+            assertNull(topology, "Topology should be null");

         } else {
         } else {

-            assertNull("Topology should be null", null);
+            assertNull(null, "Topology should be null");

         }
     }
 
         }
     }
 


@@ -102,5 +102,4 @@ public class TapiTopologyImplExceptionTest {
             // TODO Auto-generated method stub
         }
     }
             // TODO Auto-generated method stub
         }
     }

-
-}
+}
\ No newline at end of file

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java
index a78040dc0ef609c5cbebd383fb5750f5b2e11b9e..fd339a28bf644051259cd71d3f3c7bcb7375427e 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java
@@ -10,8 +10,8 @@ package org.opendaylight.transportpce.tapi.topology;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.either;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.either;
 import static org.hamcrest.MatcherAssert.assertThat;

-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;

 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;


@@ -27,8 +27,8 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.Nullable;
 import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.Nullable;

-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;

 import org.opendaylight.transportpce.common.InstanceIdentifiers;
 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
 import org.opendaylight.transportpce.common.InstanceIdentifiers;
 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
 import org.opendaylight.transportpce.common.network.NetworkTransactionService;


@@ -84,16 +84,16 @@ public class TapiTopologyImplTest extends AbstractTest {
     private static ListeningExecutorService executorService;
     private static CountDownLatch endSignal;
     private static final int NUM_THREADS = 3;
     private static ListeningExecutorService executorService;
     private static CountDownLatch endSignal;
     private static final int NUM_THREADS = 3;

-    public static NetworkTransactionService networkTransactionService;
-    public static TapiContext tapiContext;
-    public static TopologyUtils topologyUtils;
-    public static ConnectivityUtils connectivityUtils;
-    public static ServiceDataStoreOperations serviceDataStoreOperations;
-    public static TapiInitialORMapping tapiInitialORMapping;
-    public static TapiLink tapiLink;
+    private static NetworkTransactionService networkTransactionService;
+    private static TapiContext tapiContext;
+    private static TopologyUtils topologyUtils;
+    private static ConnectivityUtils connectivityUtils;
+    private static ServiceDataStoreOperations serviceDataStoreOperations;
+    private static TapiInitialORMapping tapiInitialORMapping;
+    private static TapiLink tapiLink;

 
 

-    @BeforeClass
-    public static void setUp() throws InterruptedException, ExecutionException {
+    @BeforeAll
+    static void setUp() throws InterruptedException, ExecutionException {

         executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS));
         endSignal = new CountDownLatch(1);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
         executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS));
         endSignal = new CountDownLatch(1);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),


@@ -119,7 +119,7 @@ public class TapiTopologyImplTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void getTopologyDetailsForTransponder100GTopologyWhenSuccessful()
+    void getTopologyDetailsForTransponder100GTopologyWhenSuccessful()

             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.TPDR_100G);
             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.TPDR_100G);


@@ -135,37 +135,35 @@ public class TapiTopologyImplTest extends AbstractTest {
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         @Nullable
         Topology topology = rpcResult.getResult().getTopology();
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         @Nullable
         Topology topology = rpcResult.getResult().getTopology();

-        assertNotNull("Topology should not be null", topology);
+        assertNotNull(topology, "Topology should not be null");

         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.TPDR_100G.getBytes(StandardCharsets.UTF_8))
             .toString());
         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.TPDR_100G.getBytes(StandardCharsets.UTF_8))
             .toString());

-        assertEquals("incorrect topology uuid", topoUuid, topology.getUuid());
-        assertEquals("Node list size should be 1", 1, topology.getNode().size());
+        assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid");
+        assertEquals(1, topology.getNode().size(), "Node list size should be 1");

         Name nodeName = topology.getNode().values().stream().findFirst().get().getName()
             .get(new NameKey("Tpdr100g node name"));
         Name nodeName = topology.getNode().values().stream().findFirst().get().getName()
             .get(new NameKey("Tpdr100g node name"));

-        assertEquals("Node name should be 'Tpdr100g over WDM node'", "Tpdr100g over WDM node", nodeName.getValue());
+        assertEquals("Tpdr100g over WDM node", nodeName.getValue(), "Node name should be 'Tpdr100g over WDM node'");

         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(nodeName.getValue().getBytes(StandardCharsets.UTF_8))
             .toString());
         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(nodeName.getValue().getBytes(StandardCharsets.UTF_8))
             .toString());

-        assertEquals("incorrect node uuid", nodeUuid, topology.getNode().values().stream().findFirst().get().getUuid());
+        assertEquals(nodeUuid, topology.getNode().values().stream().findFirst().get().getUuid(), "incorrect node uuid");

         long nb = topology.getNode().values().stream().findFirst().get().getOwnedNodeEdgePoint().size();
         long nb = topology.getNode().values().stream().findFirst().get().getOwnedNodeEdgePoint().size();

-        assertEquals("'Transponder 100GE' node should have 2 neps", 2, nb);
+        assertEquals(2, nb, "'Transponder 100GE' node should have 2 neps");

         List<NodeRuleGroup> nrgList = topology.getNode().values().stream().findFirst().get().nonnullNodeRuleGroup()
             .values().stream().sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
             .collect(Collectors.toList());
         List<NodeRuleGroup> nrgList = topology.getNode().values().stream().findFirst().get().nonnullNodeRuleGroup()
             .values().stream().sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
             .collect(Collectors.toList());

-        assertEquals("'Transponder 100GE' node should contain a single node rule groups", 1, nrgList.size());
+        assertEquals(1, nrgList.size(), "'Transponder 100GE' node should contain a single node rule groups");

         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());

-        assertEquals("'Transponder 100GE' node -rule-group should contain 2 NEPs", nb, nodeEdgePointList.size());
+        assertEquals(nb, nodeEdgePointList.size(), "'Transponder 100GE' node -rule-group should contain 2 NEPs");

         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
         List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());

-        assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
-        assertEquals("local-id of the rule should be 'forward'",
-            "forward", ruleList.get(0).getLocalId());
-        assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
-            ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
-        assertEquals("the rule type should be 'FORWARDING'",
-            RuleType.FORWARDING, ruleList.get(0).getRuleType());
+        assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
+        assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
+        assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(),
+            "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
+        assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'");

     }
 
     @Test
     }
 
     @Test

-    public void getTopologyDetailsForOtnTopologyWithOtnLinksWhenSuccessful()
+    void getTopologyDetailsForOtnTopologyWithOtnLinksWhenSuccessful()

             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_MULTILAYER);
             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_MULTILAYER);


@@ -181,8 +179,8 @@ public class TapiTopologyImplTest extends AbstractTest {
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         @Nullable
         Topology topology = rpcResult.getResult().getTopology();
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         @Nullable
         Topology topology = rpcResult.getResult().getTopology();

-        assertNotNull("Topology should not be null", topology);
-        assertEquals("Node list size should be 13", 13, topology.getNode().size());
+        assertNotNull(topology, "Topology should not be null");
+        assertEquals(13, topology.getNode().size(), "Node list size should be 13");

         long nb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
         long nb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()


@@ -190,7 +188,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr"))))
             .count();
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr"))))
             .count();

-        assertEquals("XPDR-A1-XPDR1 should only have one client nep", 1, nb1);
+        assertEquals(1, nb1, "XPDR-A1-XPDR1 should only have one client nep");

         long nb2 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
         long nb2 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()


@@ -198,7 +196,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1 (mux) should have 4 client neps", 4, nb2);
+        assertEquals(4, nb2, "SPDR-SA1-XPDR1 (mux) should have 4 client neps");

         long nb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
         long nb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()


@@ -206,7 +204,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1 (mux) should have a single network nep", 1, nb3);
+        assertEquals(1, nb3, "SPDR-SA1-XPDR1 (mux) should have a single network nep");

         long nb4 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
         long nb4 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()


@@ -214,7 +212,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2 (switch) should have 4 client neps", 4, nb4);
+        assertEquals(4, nb4, "SPDR-SA1-XPDR2 (switch) should have 4 client neps");

         long nb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
         long nb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()


@@ -222,29 +220,30 @@ public class TapiTopologyImplTest extends AbstractTest {
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2 (switch) should have 2 network neps", 2, nb5);
-        assertEquals("Link list size should be 18", 18, topology.getLink().size());
+        assertEquals(2, nb5, "SPDR-SA1-XPDR2 (switch) should have 2 network neps");
+        assertEquals(18, topology.getLink().size(), "Link list size should be 18");

         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Multi-layer topology".getBytes()).toString());
         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Multi-layer topology".getBytes()).toString());

-        assertEquals("incorrect topology uuid", topoUuid, topology.getUuid());
-        assertEquals("topology name should be T0 - Multi-layer topology",
+        assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid");
+        assertEquals(

             "T0 - Multi-layer topology",
             "T0 - Multi-layer topology",

-            topology.nonnullName().values().stream().findFirst().get().getValue());
+            topology.nonnullName().values().stream().findFirst().get().getValue(),
+            "topology name should be T0 - Multi-layer topology");

 
         long nbDsrOduNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count();
         long nbPhotonicNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count();
 
         long nbDsrOduNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count();
         long nbPhotonicNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count();

-        assertEquals("Node list should contain 6 DSR-ODU nodes", 6, nbDsrOduNodes);
-        assertEquals("Node list should contain 7 Photonics nodes", 7, nbPhotonicNodes);
+        assertEquals(6, nbDsrOduNodes, "Node list should contain 6 DSR-ODU nodes");
+        assertEquals(7, nbPhotonicNodes, "Node list should contain 7 Photonics nodes");

         long nbTransititionalLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("transitional link name"))).count();
         long nbOmsLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("OMS link name"))).count();
         long nbOtnLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("otn link name"))).count();
         long nbTransititionalLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("transitional link name"))).count();
         long nbOmsLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("OMS link name"))).count();
         long nbOtnLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("otn link name"))).count();

-        assertEquals("Link list should contain 8 transitional links", 8, nbTransititionalLinks);
-        assertEquals("Link list should contain 8 transitional links", 8, nbOmsLinks);
-        assertEquals("Link list should contain 2 OTN links", 2, nbOtnLinks);
+        assertEquals(8, nbTransititionalLinks, "Link list should contain 8 transitional links");
+        assertEquals(8, nbOmsLinks, "Link list should contain 8 transitional links");
+        assertEquals(2, nbOtnLinks, "Link list should contain 2 OTN links");

 
         Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(StandardCharsets.UTF_8))
             .toString());
 
         Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(StandardCharsets.UTF_8))
             .toString());


@@ -280,7 +279,7 @@ public class TapiTopologyImplTest extends AbstractTest {
     }
 
     @Test
     }
 
     @Test

-    public void getTopologyDetailsForFullTapiTopologyWithLinksWhenSuccessful()
+    void getTopologyDetailsForFullTapiTopologyWithLinksWhenSuccessful()

             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_FULL_MULTILAYER);
             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_FULL_MULTILAYER);


@@ -296,9 +295,9 @@ public class TapiTopologyImplTest extends AbstractTest {
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         @Nullable
         Topology topology = rpcResult.getResult().getTopology();
         RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
         @Nullable
         Topology topology = rpcResult.getResult().getTopology();

-        assertNotNull("Topology should not be null", topology);
+        assertNotNull(topology, "Topology should not be null");

         // 2 Nodes per Xpdr/Spdr node (DSR-ODU & PHOT) + 1 Node per Roadm
         // 2 Nodes per Xpdr/Spdr node (DSR-ODU & PHOT) + 1 Node per Roadm

-        assertEquals("Node list size should be 18", 18, topology.getNode().size());
+        assertEquals(18, topology.getNode().size(), "Node list size should be 18");

         long nb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR"))
         long nb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR"))


@@ -306,63 +305,63 @@ public class TapiTopologyImplTest extends AbstractTest {
                 .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr"))))
             .count();
         // 2 client ports in configuration -> removed the checkTp so we have 2 NEPs
                 .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr"))))
             .count();
         // 2 client ports in configuration -> removed the checkTp so we have 2 NEPs

-        assertEquals("XPDR-A1-XPDR1+DSR should only have two client neps", 2, nb1);
+        assertEquals(2, nb1, "XPDR-A1-XPDR1+DSR should only have two client neps");

         long inb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();
         long inb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();

-        assertEquals("XPDR-A1-XPDR1+DSR should only have two internal network neps", 2, inb1);
+        assertEquals(2, inb1, "XPDR-A1-XPDR1+DSR should only have two internal network neps");

         long enb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
             .count();
         long enb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
             .count();

-        assertEquals("XPDR-A1-XPDR1+DSR should only have two external network neps", 2, enb1);
+        assertEquals(2, enb1, "XPDR-A1-XPDR1+DSR should only have two external network neps");

         long nb2 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();
         long nb2 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1+DSR (mux) should have 4 client neps", 4, nb2);
+        assertEquals(4, nb2, "SPDR-SA1-XPDR1+DSR (mux) should have 4 client neps");

         long inb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();
         long inb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1+DSR (mux) should have a single internal network nep", 1, inb3);
+        assertEquals(1, inb3, "SPDR-SA1-XPDR1+DSR (mux) should have a single internal network nep");

         long enb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
             .count();
         long enb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1+DSR (mux) should have 4 external network nep", 4, enb3);
+        assertEquals(4, enb3, "SPDR-SA1-XPDR1+DSR (mux) should have 4 external network nep");

         long nb4 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();
         long nb4 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2+DSR (switch) should have 4 client neps", 4, nb4);
+        assertEquals(4, nb4, "SPDR-SA1-XPDR2+DSR (switch) should have 4 client neps");

         long inb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();
         long inb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2+DSR (switch) should have 4 internal network neps", 4, inb5);
+        assertEquals(4, inb5, "SPDR-SA1-XPDR2+DSR (switch) should have 4 internal network neps");

         long enb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
             .count();
         long enb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2+DSR (switch) should have 4 external network neps", 4, enb5);
+        assertEquals(4, enb5, "SPDR-SA1-XPDR2+DSR (switch) should have 4 external network neps");

 
         // Now lets check for the Photonic media nodes (same nodes as for DSR + 1 Roadm node)
         nb1 = topology.getNode().values().stream()
 
         // Now lets check for the Photonic media nodes (same nodes as for DSR + 1 Roadm node)
         nb1 = topology.getNode().values().stream()


@@ -372,63 +371,63 @@ public class TapiTopologyImplTest extends AbstractTest {
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint"))))
             .count();
         // 2 client ports in configuration -> removed the checkTp so we have 2 NEPs
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint"))))
             .count();
         // 2 client ports in configuration -> removed the checkTp so we have 2 NEPs

-        assertEquals("XPDR-A1-XPDR1+OTSi should only have two internal network neps", 2, nb1);
+        assertEquals(2, nb1, "XPDR-A1-XPDR1+OTSi should only have two internal network neps");

         inb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
             .count();
         inb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
             .count();

-        assertEquals("XPDR-A1-XPDR1+OTSi should only have two external network neps", 2, inb1);
+        assertEquals(2, inb1, "XPDR-A1-XPDR1+OTSi should only have two external network neps");

         enb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint"))))
             .count();
         enb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint"))))
             .count();

-        assertEquals("XPDR-A1-XPDR1+OTSi should only have two photonic network neps", 2, enb1);
+        assertEquals(2, enb1, "XPDR-A1-XPDR1+OTSi should only have two photonic network neps");

         nb2 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint"))))
             .count();
         nb2 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1+OTSi (mux) should have a single internal network nep", 1, nb2);
+        assertEquals(1, nb2, "SPDR-SA1-XPDR1+OTSi (mux) should have a single internal network nep");

         inb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
             .count();
         inb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1+OTSi (mux) should have a single external network nep", 1, inb3);
+        assertEquals(1, inb3, "SPDR-SA1-XPDR1+OTSi (mux) should have a single external network nep");

         enb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint"))))
             .count();
         enb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR1+OTSi (mux) should have a single photonic network nep", 1, enb3);
+        assertEquals(1, enb3, "SPDR-SA1-XPDR1+OTSi (mux) should have a single photonic network nep");

         nb4 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint"))))
             .count();
         nb4 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2+OTSi (switch) should have 4 internal network neps", 4, nb4);
+        assertEquals(4, nb4, "SPDR-SA1-XPDR2+OTSi (switch) should have 4 internal network neps");

         inb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
             .count();
         inb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2+OTSi (switch) should have 4 external network neps", 4, inb5);
+        assertEquals(4, inb5, "SPDR-SA1-XPDR2+OTSi (switch) should have 4 external network neps");

         enb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint"))))
             .count();
         enb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint"))))
             .count();

-        assertEquals("SPDR-SA1-XPDR2+OTSi (switch) should have 4 photonic network neps", 4, enb5);
+        assertEquals(4, enb5, "SPDR-SA1-XPDR2+OTSi (switch) should have 4 photonic network neps");

         // We should have 3 neps per DEGREE-TTP port and 3 neps per SRG-PP port
         long inb6 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
         // We should have 3 neps per DEGREE-TTP port and 3 neps per SRG-PP port
         long inb6 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))


@@ -437,7 +436,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().values().stream().findFirst().get().getValue().contains("DEG")))
             .count();
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().values().stream().findFirst().get().getValue().contains("DEG")))
             .count();

-        assertEquals("ROADM-A1+PHOTONIC_MEDIA (DEGREE) should have 6 network neps", 6, inb6);
+        assertEquals(6, inb6, "ROADM-A1+PHOTONIC_MEDIA (DEGREE) should have 6 network neps");

         long enb6 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals(
         long enb6 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
             .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals(


@@ -445,25 +444,26 @@ public class TapiTopologyImplTest extends AbstractTest {
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().values().stream().findFirst().get().getValue().contains("SRG")))
             .count();
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().values().stream().findFirst().get().getValue().contains("SRG")))
             .count();

-        assertEquals("ROADM-A1+PHOTONIC_MEDIA (SRG) should have 24 network neps", 24, enb6);
+        assertEquals(24, enb6, "ROADM-A1+PHOTONIC_MEDIA (SRG) should have 24 network neps");

 
         // Links in openroadm topology which include Roadm-to-Roadm and Xpdr-to-Roadm (ortopo / 2)
         // + transitional links -> 1 per network port of Xpdr + OTN links / 2
 
         // Links in openroadm topology which include Roadm-to-Roadm and Xpdr-to-Roadm (ortopo / 2)
         // + transitional links -> 1 per network port of Xpdr + OTN links / 2

-        assertEquals("Link list size should be 25", 25, topology.getLink().size());
+        assertEquals(25, topology.getLink().size(), "Link list size should be 25");

         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Full Multi-layer topology".getBytes()).toString());
         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Full Multi-layer topology".getBytes()).toString());

-        assertEquals("incorrect topology uuid", topoUuid, topology.getUuid());
-        assertEquals("topology name should be T0 - Full Multi-layer topology",
+        assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid");
+        assertEquals(

             "T0 - Full Multi-layer topology",
             "T0 - Full Multi-layer topology",

-            topology.nonnullName().values().stream().findFirst().get().getValue());
+            topology.nonnullName().values().stream().findFirst().get().getValue(),
+            "topology name should be T0 - Full Multi-layer topology");

 
         long nbDsrOduNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count();
         long nbPhotonicNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count();
         // In DSR/ODU we create one node per Xpdr (no filtering out)
 
         long nbDsrOduNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count();
         long nbPhotonicNodes = topology.nonnullNode().values().stream()
             .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count();
         // In DSR/ODU we create one node per Xpdr (no filtering out)

-        assertEquals("Node list should contain 8 DSR-ODU nodes", 8, nbDsrOduNodes);
+        assertEquals(8, nbDsrOduNodes, "Node list should contain 8 DSR-ODU nodes");

         // We need to add the Roadms as Photonic nodes. Instead of 1 node as roadm infra we have 2 roadm nodes
         // We need to add the Roadms as Photonic nodes. Instead of 1 node as roadm infra we have 2 roadm nodes

-        assertEquals("Node list should contain 8 Photonics nodes", 8, nbPhotonicNodes);
+        assertEquals(8, nbPhotonicNodes, "Node list should contain 8 Photonics nodes");

         long nbTransititionalLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("transitional link name"))).count();
         // Roadm-to-Roadm
         long nbTransititionalLinks = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("transitional link name"))).count();
         // Roadm-to-Roadm


@@ -473,13 +473,13 @@ public class TapiTopologyImplTest extends AbstractTest {
         long nbOmsLinks1 = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("XPDR-RDM link name"))).count();
         // 1 transitional link per NETWORK port
         long nbOmsLinks1 = topology.getLink().values().stream()
             .filter(l -> l.getName().containsKey(new NameKey("XPDR-RDM link name"))).count();
         // 1 transitional link per NETWORK port

-        assertEquals("Link list should contain 16 transitional links", 16, nbTransititionalLinks);
+        assertEquals(16, nbTransititionalLinks, "Link list should contain 16 transitional links");

         // 1 OMS per ROADM-to-ROADM link + Existing XPDR-tp-ROADM link in openroadm topology
         // 1 OMS per ROADM-to-ROADM link + Existing XPDR-tp-ROADM link in openroadm topology

-        assertEquals("Link list should contain 9 OMS links", 9, nbOmsLinks + nbOmsLinks1);
+        assertEquals(9, nbOmsLinks + nbOmsLinks1, "Link list should contain 9 OMS links");

     }
 
     @Test
     }
 
     @Test

-    public void getNodeAndNepsDetailsWhenSuccessful()
+    void getNodeAndNepsDetailsWhenSuccessful()

             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_FULL_MULTILAYER);
             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_FULL_MULTILAYER);


@@ -510,7 +510,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             RpcResult<GetNodeDetailsOutput> rpcResult1 = result1.get();
             @Nullable
             Node node1 = rpcResult1.getResult().getNode();
             RpcResult<GetNodeDetailsOutput> rpcResult1 = result1.get();
             @Nullable
             Node node1 = rpcResult1.getResult().getNode();

-            assertNotNull("Node should not be null", node1);
+            assertNotNull(node1, "Node should not be null");

             for (OwnedNodeEdgePoint onep:node1.getOwnedNodeEdgePoint().values()) {
                 String onepName = onep.getName().values().stream().findFirst().get().getValue();
                 GetNodeEdgePointDetailsInput input2 = TapiTopologyDataUtils.buildGetNodeEdgePointDetailsInput(
             for (OwnedNodeEdgePoint onep:node1.getOwnedNodeEdgePoint().values()) {
                 String onepName = onep.getName().values().stream().findFirst().get().getValue();
                 GetNodeEdgePointDetailsInput input2 = TapiTopologyDataUtils.buildGetNodeEdgePointDetailsInput(


@@ -528,13 +528,13 @@ public class TapiTopologyImplTest extends AbstractTest {
                 org.opendaylight.yang.gen.v1
                     .urn.onf.otcc.yang.tapi.topology.rev181210.get.node.edge.point.details.output.NodeEdgePoint
                     onep1 = rpcResult2.getResult().getNodeEdgePoint();
                 org.opendaylight.yang.gen.v1
                     .urn.onf.otcc.yang.tapi.topology.rev181210.get.node.edge.point.details.output.NodeEdgePoint
                     onep1 = rpcResult2.getResult().getNodeEdgePoint();

-                assertNotNull("Node Edge Point should not be null", onep1);
+                assertNotNull(onep1, "Node Edge Point should not be null");

             }
         }
     }
 
     @Test
             }
         }
     }
 
     @Test

-    public void getLinkDetailsWhenSuccessful()
+    void getLinkDetailsWhenSuccessful()

             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_FULL_MULTILAYER);
             throws ExecutionException, InterruptedException {
         GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(
             TapiStringConstants.T0_FULL_MULTILAYER);


@@ -565,12 +565,12 @@ public class TapiTopologyImplTest extends AbstractTest {
             RpcResult<GetLinkDetailsOutput> rpcResult1 = result1.get();
             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.link.details.output.Link link1
                 = rpcResult1.getResult().getLink();
             RpcResult<GetLinkDetailsOutput> rpcResult1 = result1.get();
             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.link.details.output.Link link1
                 = rpcResult1.getResult().getLink();

-            assertNotNull("Link should not be null", link1);
+            assertNotNull(link1, "Link should not be null");

         }
     }
 
     @Test
         }
     }
 
     @Test

-    public void getSipDetailsWhenSuccessful()
+    void getSipDetailsWhenSuccessful()

             throws ExecutionException, InterruptedException {
         GetServiceInterfacePointListInput input = TapiTopologyDataUtils.buildServiceInterfacePointListInput();
         TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils, tapiLink);
             throws ExecutionException, InterruptedException {
         GetServiceInterfacePointListInput input = TapiTopologyDataUtils.buildServiceInterfacePointListInput();
         TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils, tapiLink);


@@ -602,28 +602,28 @@ public class TapiTopologyImplTest extends AbstractTest {
             org.opendaylight.yang.gen.v1
                 .urn.onf.otcc.yang.tapi.common.rev181210.get.service._interface.point.details.output.Sip sip1
                 = rpcResult1.getResult().getSip();
             org.opendaylight.yang.gen.v1
                 .urn.onf.otcc.yang.tapi.common.rev181210.get.service._interface.point.details.output.Sip sip1
                 = rpcResult1.getResult().getSip();

-            assertNotNull("Sip should not be null", sip1);
+            assertNotNull(sip1, "Sip should not be null");

         }
     }
 
     private void checkOtnLink(Link link, Uuid topoUuid, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid,
             Uuid linkUuid, String linkName) {
         }
     }
 
     private void checkOtnLink(Link link, Uuid topoUuid, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid,
             Uuid linkUuid, String linkName) {

-        assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("otn link name")).getValue());
-        assertEquals("bad uuid for link", linkUuid, link.getUuid());
-        assertEquals("Available capacity unit should be MBPS",
-            CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit());
+        assertEquals(linkName, link.getName().get(new NameKey("otn link name")).getValue(), "bad name for the link");
+        assertEquals(linkUuid, link.getUuid(), "bad uuid for link");
+        assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(),
+            "Available capacity unit should be MBPS");

         String prefix = linkName.split("-")[0];
         if ("OTU4".equals(prefix)) {
         String prefix = linkName.split("-")[0];
         if ("OTU4".equals(prefix)) {

-            assertEquals("Available capacity -total size value should be 0",
-                Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue());
+            assertEquals(Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue(),
+                "Available capacity -total size value should be 0");

         } else if ("ODTU4".equals(prefix)) {
         } else if ("ODTU4".equals(prefix)) {

-            assertEquals("Available capacity -total size value should be 100 000",
-                Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue());
+            assertEquals(Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue(),
+                "Available capacity -total size value should be 100 000");

         }
         }

-        assertEquals("Total capacity unit should be GBPS",
-            CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit());
-        assertEquals("Total capacity -total size value should be 100",
-            Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue());
+        assertEquals(CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit(),
+            "Total capacity unit should be GBPS");
+        assertEquals(Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue(),
+            "Total capacity -total size value should be 100");

         if ("OTU4".equals(prefix)) {
             assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
                 LayerProtocolName.PHOTONICMEDIA.getName(),
         if ("OTU4".equals(prefix)) {
             assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
                 LayerProtocolName.PHOTONICMEDIA.getName(),


@@ -633,14 +633,14 @@ public class TapiTopologyImplTest extends AbstractTest {
                 LayerProtocolName.ODU.getName(),
                 link.getLayerProtocolName().stream().findFirst().get().getName());
         }
                 LayerProtocolName.ODU.getName(),
                 link.getLayerProtocolName().stream().findFirst().get().getName());
         }

-        assertEquals("transitional link should be BIDIRECTIONAL",
-            ForwardingDirection.BIDIRECTIONAL, link.getDirection());
+        assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(),
+            "transitional link should be BIDIRECTIONAL");

         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
             .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());

-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topoUuid, nodeEdgePointList.get(0).getTopologyUuid());
-        assertEquals("topology uuid should be the same for the two termination point of the link",
-            topoUuid, nodeEdgePointList.get(1).getTopologyUuid());
+        assertEquals(topoUuid, nodeEdgePointList.get(0).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");
+        assertEquals(topoUuid, nodeEdgePointList.get(1).getTopologyUuid(),
+            "topology uuid should be the same for the two termination point of the link");

         assertThat("otn links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
         assertThat("otn links should terminate on two distinct nodes",
             nodeEdgePointList.get(0).getNodeUuid().getValue(),
             either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));


@@ -653,9 +653,8 @@ public class TapiTopologyImplTest extends AbstractTest {
         assertThat("otn links should terminate on two distinct tps",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
         assertThat("otn links should terminate on two distinct tps",
             nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
             either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));

-        assertEquals("operational state should be ENABLED",
-            OperationalState.ENABLED, link.getOperationalState());
-        assertEquals("administrative state should be UNLOCKED",
-            AdministrativeState.UNLOCKED, link.getAdministrativeState());
+        assertEquals(OperationalState.ENABLED, link.getOperationalState(), "operational state should be ENABLED");
+        assertEquals(AdministrativeState.UNLOCKED, link.getAdministrativeState(),
+            "administrative state should be UNLOCKED");

     }
     }

-}
+}
\ No newline at end of file

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java
index a5277619b2422502ac349c2969f5cace608f6da8..cd4347f0290974322a2f7a92a675126c4499c21c 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java
@@ -117,7 +117,6 @@ public final class TapiConnectivityDataUtils {
     }
 
     public static ServiceCreateInput buildServiceCreateInput() {
     }
 
     public static ServiceCreateInput buildServiceCreateInput() {

-

         return new ServiceCreateInputBuilder()
             .setCommonId("commonId")
             .setConnectionType(ConnectionType.Service)
         return new ServiceCreateInputBuilder()
             .setCommonId("commonId")
             .setConnectionType(ConnectionType.Service)

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java
index 32cbbf19ed9acf8bcda4db2331f854b94fa0bef3..8b5b655a925fce9f093b3db147f6402c5046fb56 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java
@@ -29,44 +29,45 @@ public final class TapiTopologyDataUtils {
     public static final String PORTMAPPING_FILE = "src/test/resources/portmapping.xml";
 
     public static GetTopologyDetailsInput buildGetTopologyDetailsInput(String topoName) {
     public static final String PORTMAPPING_FILE = "src/test/resources/portmapping.xml";
 
     public static GetTopologyDetailsInput buildGetTopologyDetailsInput(String topoName) {

-        GetTopologyDetailsInputBuilder builtInput = new GetTopologyDetailsInputBuilder();
-        builtInput.setTopologyIdOrName(topoName);
-        return builtInput.build();
+        return new GetTopologyDetailsInputBuilder()
+            .setTopologyIdOrName(topoName)
+            .build();

     }
 
     public static GetNodeDetailsInput buildGetNodeDetailsInput(String topoName, String nodeName) {
     }
 
     public static GetNodeDetailsInput buildGetNodeDetailsInput(String topoName, String nodeName) {

-        GetNodeDetailsInputBuilder builtInput = new GetNodeDetailsInputBuilder();
-        builtInput.setTopologyIdOrName(topoName);
-        builtInput.setNodeIdOrName(nodeName);
-        return builtInput.build();
+        return new GetNodeDetailsInputBuilder()
+            .setTopologyIdOrName(topoName)
+            .setNodeIdOrName(nodeName)
+            .build();

     }
 
     public static GetLinkDetailsInput buildGetLinkDetailsInput(String topoName, String linkName) {
     }
 
     public static GetLinkDetailsInput buildGetLinkDetailsInput(String topoName, String linkName) {

-        GetLinkDetailsInputBuilder builtInput = new GetLinkDetailsInputBuilder();
-        builtInput.setTopologyIdOrName(topoName);
-        builtInput.setLinkIdOrName(linkName);
-        return builtInput.build();
+        return new GetLinkDetailsInputBuilder()
+            .setTopologyIdOrName(topoName)
+            .setLinkIdOrName(linkName)
+            .build();

     }
 
     public static GetServiceInterfacePointListInput buildServiceInterfacePointListInput() {
     }
 
     public static GetServiceInterfacePointListInput buildServiceInterfacePointListInput() {

-        return new GetServiceInterfacePointListInputBuilder().build();
+        return new GetServiceInterfacePointListInputBuilder()
+            .build();

     }
 
     public static GetServiceInterfacePointDetailsInput buildGetServiceInterfacePointDetailsInput(Uuid sipUuid) {
     }
 
     public static GetServiceInterfacePointDetailsInput buildGetServiceInterfacePointDetailsInput(Uuid sipUuid) {

-        GetServiceInterfacePointDetailsInputBuilder builtInput = new GetServiceInterfacePointDetailsInputBuilder();
-        builtInput.setSipIdOrName(sipUuid.getValue());
-        return builtInput.build();
+        return new GetServiceInterfacePointDetailsInputBuilder()
+            .setSipIdOrName(sipUuid.getValue())
+            .build();

     }
 
     }
 

-    public static GetNodeEdgePointDetailsInput buildGetNodeEdgePointDetailsInput(String topoName,
-                                                                                 String nodeName, String onepName) {
-        GetNodeEdgePointDetailsInputBuilder builtInput = new GetNodeEdgePointDetailsInputBuilder();
-        builtInput.setTopologyIdOrName(topoName);
-        builtInput.setNodeIdOrName(nodeName);
-        builtInput.setEpIdOrName(onepName);
-        return builtInput.build();
+    public static GetNodeEdgePointDetailsInput buildGetNodeEdgePointDetailsInput(String topoName, String nodeName,
+            String onepName) {
+        return new GetNodeEdgePointDetailsInputBuilder()
+            .setTopologyIdOrName(topoName)
+            .setNodeIdOrName(nodeName)
+            .setEpIdOrName(onepName)
+            .build();

     }
 
     private TapiTopologyDataUtils() {
     }
     }
 
     private TapiTopologyDataUtils() {
     }

-}
+}
\ No newline at end of file