Migrate common module to Aluminium Step 1

JIRA: TRNSPRTPCE-292 TRNSPRTPCE-297
Signed-off-by: guillaume.lambert <guillaume.lambert@orange.com>
Change-Id: I9d264136b83d1267cee4e59520b0a682d4258c24

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl121.java b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl121.java
index 8ee2350d0c82e4e12d48f6022c1b69b202f19034..96b94f5c0a371fda66d0c5fbb5cf49f20542f56c 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl121.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl121.java
@@ -38,6 +38,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.open
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -60,7 +61,7 @@ public class CrossConnectImpl121 {
         RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder();
         String connectionNumber = generateConnectionNumber(srcTp, destTp, waveNumber);
         rdmConnBldr.setConnectionNumber(connectionNumber);
-        rdmConnBldr.setWavelengthNumber(waveNumber);
+        rdmConnBldr.setWavelengthNumber(Uint32.valueOf(waveNumber));
         rdmConnBldr.setOpticalControlMode(OpticalControlMode.Off);
         rdmConnBldr.setSource(new SourceBuilder().setSrcIf(srcTp + "-" + waveNumber.toString()).build());
         rdmConnBldr.setDestination(new DestinationBuilder().setDstIf(destTp + "-" + waveNumber.toString()).build());

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
index 9b1764671fa648de9ff9b4fd685575d45160dd64..db98a33c4cece5995cb4489df27c9aa56c5adb0f 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
@@ -14,6 +14,7 @@ import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Base64;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -67,6 +68,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.open
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Protocols;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.Destination;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex;
@@ -75,6 +77,8 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.Lldp;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfig;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -205,7 +209,8 @@ public class PortMappingVersion121 {
         Map<String, Mapping> mappingMap = new HashMap<>();
 
         // com.google.common.collect.ImmutableList implementation of List
-        List<CircuitPacks> circuitPackList = new ArrayList<>(deviceObject.get().getCircuitPacks());
+        List<CircuitPacks> circuitPackList = new ArrayList<>(deviceObject.get()
+                .nonnullCircuitPacks().values());
         circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName));
 
         for (CircuitPacks cp : circuitPackList) {
@@ -216,7 +221,7 @@ public class PortMappingVersion121 {
             }
 
             // com.google.common.collect.ImmutableList implementation of List
-            List<Ports> portList = new ArrayList<>(cp.getPorts());
+            List<Ports> portList = new ArrayList<>(cp.nonnullPorts().values());
             portList.sort(Comparator.comparing(Ports::getPortName));
             for (Ports port : portList) {
                 if (port.getPortQual() == null) {
@@ -242,7 +247,8 @@ public class PortMappingVersion121 {
                     Optional<CircuitPacks> cpOpt = circuitPackList.stream().filter(cP -> cP.getCircuitPackName()
                         .equals(port.getPartnerPort().getCircuitPackName())).findFirst();
                     if (cpOpt.isPresent()) {
-                        Optional<Ports> poOpt = cpOpt.get().getPorts().stream().filter(p -> p.getPortName().equals(port
+                        Optional<Ports> poOpt = cpOpt.get().nonnullPorts()
+                                .values().stream().filter(p -> p.getPortName().equals(port
                             .getPartnerPort().getPortName().toString())).findFirst();
                         if (poOpt.isPresent()) {
                             Ports port2 = poOpt.get();
@@ -296,7 +302,7 @@ public class PortMappingVersion121 {
                 }
             }
         }
-        List<ConnectionMap> connectionMap = deviceObject.get().getConnectionMap();
+        Collection<ConnectionMap> connectionMap = deviceObject.get().nonnullConnectionMap().values();
         String slcp = null;
         String dlcp = null;
         for (ConnectionMap cm : connectionMap) {
@@ -304,8 +310,8 @@ public class PortMappingVersion121 {
             if (lcpMap.containsKey(skey)) {
                 slcp = lcpMap.get(skey);
             }
-            String dkey = cm.getDestination().get(0).getCircuitPackName() + "+"
-                + cm.getDestination().get(0).getPortName();
+            Destination destination0 = cm.nonnullDestination().values().iterator().next();
+            String dkey = destination0.getCircuitPackName() + "+" + destination0.getPortName();
             if (lcpMap.containsKey(dkey)) {
                 dlcp = lcpMap.get(dkey);
             }
@@ -342,12 +348,12 @@ public class PortMappingVersion121 {
                 = new ArrayList<>();
             LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter);
             InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
+                .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(srgCounter)));
             Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
                 LogicalDatastoreType.OPERATIONAL, srgIID,
                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
             if (ordmSrgObject.isPresent()) {
-                srgCps.addAll(ordmSrgObject.get().getCircuitPacks());
+                srgCps.addAll(ordmSrgObject.get().nonnullCircuitPacks().values());
                 cpPerSrg.put(ordmSrgObject.get().getSrgNumber().toJava(), srgCps);
             }
         }
@@ -380,7 +386,7 @@ public class PortMappingVersion121 {
                 }
                 // com.google.common.collect.ImmutableList implementation of List
                 @Nullable
-                List<Ports> portList = new ArrayList<>(circuitPackObject.get().getPorts());
+                List<Ports> portList = new ArrayList<>(circuitPackObject.get().nonnullPorts().values());
                 Collections.sort(portList, new SortPort121ByName());
                 int portIndex = 1;
                 for (Ports port : portList) {
@@ -491,7 +497,7 @@ public class PortMappingVersion121 {
         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
             LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(Degree.class, new DegreeKey(degreeCounter));
+                .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter)));
             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
                 LogicalDatastoreType.OPERATIONAL, deviceIID,
                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
@@ -515,12 +521,13 @@ public class PortMappingVersion121 {
         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
             LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(Degree.class, new DegreeKey(degreeCounter));
+                .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter)));
             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
                 LogicalDatastoreType.OPERATIONAL, deviceIID,
                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
             if (ordmDegreeObject.isPresent()) {
-                conPortMap.put(degreeCounter, ordmDegreeObject.get().getConnectionPorts());
+                conPortMap.put(degreeCounter, new ArrayList<>(ordmDegreeObject.get()
+                        .nonnullConnectionPorts().values()));
             }
         }
         LOG.info("Device {} has {} degree", deviceId, conPortMap.size());
@@ -537,7 +544,7 @@ public class PortMappingVersion121 {
             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (protocolObject.isPresent() && protocolObject.get().augmentation(Protocols1.class).getLldp() != null) {
             Lldp lldp = protocolObject.get().augmentation(Protocols1.class).getLldp();
-            for (PortConfig portConfig : lldp.getPortConfig()) {
+            for (PortConfig portConfig : lldp.nonnullPortConfig().values()) {
                 if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) {
                     InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                         .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
@@ -573,7 +580,7 @@ public class PortMappingVersion121 {
         for (Degree degree : degrees) {
             if (degree.getCircuitPacks() != null) {
                 LOG.info("Inside CP to degree list");
-                cpToDegreeList.addAll(degree.getCircuitPacks().stream()
+                cpToDegreeList.addAll(degree.nonnullCircuitPacks().values().stream()
                     .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
                         degree.getDegreeNumber().toString(), nodeId, interfaceList))
                     .collect(Collectors.toList()));
@@ -590,14 +597,27 @@ public class PortMappingVersion121 {
             nodesBldr.setNodeInfo(nodeInfo);
         }
         if (portMapList != null) {
-            nodesBldr.setMapping(portMapList);
+            Map<MappingKey, Mapping> mappingMap = new HashMap<>();
+            for (Mapping mapping: portMapList) {
+                if (mapping != null) {
+                    mappingMap.put(mapping.key(), mapping);
+                }
+            }
+            nodesBldr.setMapping(mappingMap);
         }
         if (cp2DegreeList != null) {
-            nodesBldr.setCpToDegree(cp2DegreeList);
+            Map<CpToDegreeKey, CpToDegree> cpToDegreeMap = new HashMap<>();
+            for (CpToDegree cp2Degree: cp2DegreeList) {
+                if (cp2Degree != null) {
+                    cpToDegreeMap.put(cp2Degree.key(), cp2Degree);
+                }
+            }
+            nodesBldr.setCpToDegree(cpToDegreeMap);
         }
 
-        List<Nodes> nodesList = new ArrayList<>();
-        nodesList.add(nodesBldr.build());
+        Map<NodesKey,Nodes> nodesList = new HashMap<>();
+        Nodes nodes = nodesBldr.build();
+        nodesList.put(nodes.key(),nodes);
 
         NetworkBuilder nwBldr = new NetworkBuilder();
         nwBldr.setNodes(nodesList);
@@ -624,7 +644,7 @@ public class PortMappingVersion121 {
             interfaceName = interfaceList.get(circuitPackName);
         }
         return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName)
-            .setDegreeNumber(Long.valueOf(degreeNumber)).setInterfaceName(interfaceName).build();
+            .setDegreeNumber(Uint32.valueOf(degreeNumber)).setInterfaceName(interfaceName).build();
     }
 
     private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java
index 3046aca4d61e781b690a41af095c843ffab53803..4ddbb102e4312330859b172632b3ad47cc940142 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java
@@ -14,6 +14,7 @@ import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Base64;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -52,8 +53,10 @@ import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmappi
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.NodeInfoBuilder;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.SwitchingPoolLcp;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.SwitchingPoolLcpBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.SwitchingPoolLcpKey;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.switching.pool.lcp.NonBlockingList;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.switching.pool.lcp.NonBlockingListBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.switching.pool.lcp.NonBlockingListKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.Direction;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyGHz;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PortQual;
@@ -76,6 +79,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.open
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.Xponder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.connection.map.Destination;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.port.Interfaces;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.xponder.XpdrPort;
@@ -226,7 +230,7 @@ public class PortMappingVersion221 {
             LOG.warn("Circuit Packs are not present for {}", nodeId);
             return false;
         }
-        circuitPackList = new ArrayList<>(deviceObject.get().getCircuitPacks());
+        circuitPackList = new ArrayList<>(deviceObject.get().nonnullCircuitPacks().values());
         circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName));
 
         if (device.getXponder() == null) {
@@ -237,7 +241,7 @@ public class PortMappingVersion221 {
                     LOG.warn("Ports were not found for circuit pack: {}", circuitPackName);
                     continue;
                 }
-                List<Ports> portList = new ArrayList<>(cp.getPorts());
+                List<Ports> portList = new ArrayList<>(cp.nonnullPorts().values());
                 portList.sort(Comparator.comparing(Ports::getPortName));
                 for (Ports port : portList) {
                     if (port.getPortQual() == null) {
@@ -265,7 +269,7 @@ public class PortMappingVersion221 {
                             .filter(cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName()))
                             .findFirst();
                         if (cpOpt.isPresent()) {
-                            Optional<Ports> poOpt = cpOpt.get().getPorts().stream()
+                            Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
                                 .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
                                 .findFirst();
                             if (poOpt.isPresent()) {
@@ -312,35 +316,35 @@ public class PortMappingVersion221 {
             }
         } else {
             LOG.info("{} configuration contains a list of xponders", nodeId);
-            for (Xponder xponder:deviceObject.get().getXponder()) {
+            for (Xponder xponder:deviceObject.get().nonnullXponder().values()) {
                 line = 1;
                 client = 1;
                 Integer xponderNb = xponder.getXpdrNumber().toJava();
                 XpdrNodeTypes xponderType = xponder.getXpdrType();
-                for (XpdrPort xpdrPort : xponder.getXpdrPort()) {
+                for (XpdrPort xpdrPort : xponder.nonnullXpdrPort().values()) {
                     String circuitPackName = xpdrPort.getCircuitPackName();
                     String portName = xpdrPort.getPortName().toString();
                     // If there xponder-subtree has missing circuit-packs or ports,
                     // This gives a null-pointer expection,
-                    if (device.getCircuitPacks().stream()
+                    if (device.nonnullCircuitPacks().values().stream()
                             .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
                             .findFirst().isEmpty()) {
                         LOG.warn("Circuit-pack {} is missing in the device", circuitPackName);
                         LOG.warn("Port-mapping will continue ignoring this circuit-pack {}", circuitPackName);
                         continue;
                     }
-                    if (device.getCircuitPacks().stream()
+                    if (device.nonnullCircuitPacks().values().stream()
                             .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
-                            .findFirst().get().getPorts().stream()
+                            .findFirst().get().nonnullPorts().values().stream()
                             .filter(p -> p.getPortName().equals(portName))
                             .findFirst().isEmpty()) {
                         LOG.warn("Port {} associated with CP {} is missing in the device", portName, circuitPackName);
                         LOG.warn("Port-mapping will continue ignoring this port {}", portName);
                         continue;
                     }
-                    Ports port = device.getCircuitPacks().stream()
+                    Ports port = device.nonnullCircuitPacks().values().stream()
                             .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
-                            .findFirst().get().getPorts().stream()
+                            .findFirst().get().nonnullPorts().values().stream()
                             .filter(p -> p.getPortName().equals(portName))
                             .findFirst().get();
                     if (port.getPortQual() == null) {
@@ -371,7 +375,7 @@ public class PortMappingVersion221 {
                             .filter(cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName()))
                             .findFirst();
                         if (cpOpt.isPresent()) {
-                            Optional<Ports> poOpt = cpOpt.get().getPorts().stream()
+                            Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
                                 .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
                                 .findFirst();
                             if (poOpt.isPresent()) {
@@ -422,7 +426,7 @@ public class PortMappingVersion221 {
         }
 
         if (device.getConnectionMap() != null) {
-            List<ConnectionMap> connectionMap = deviceObject.get().getConnectionMap();
+            Collection<ConnectionMap> connectionMap = deviceObject.get().nonnullConnectionMap().values();
             String slcp = null;
             String dlcp = null;
             for (ConnectionMap cm : connectionMap) {
@@ -430,8 +434,8 @@ public class PortMappingVersion221 {
                 if (lcpMap.containsKey(skey)) {
                     slcp = lcpMap.get(skey);
                 }
-                String dkey = cm.getDestination().get(0).getCircuitPackName() + "+"
-                    + cm.getDestination().get(0).getPortName();
+                Destination destination0 = cm.nonnullDestination().values().iterator().next();
+                String dkey = destination0.getCircuitPackName() + "+" + destination0.getPortName();
                 if (lcpMap.containsKey(dkey)) {
                     dlcp = lcpMap.get(dkey);
                 }
@@ -447,15 +451,15 @@ public class PortMappingVersion221 {
             LOG.warn("No connection-map inside device configuration");
         }
         if (device.getOduSwitchingPools() != null) {
-            List<OduSwitchingPools> oduSwithcingPools = device.getOduSwitchingPools();
+            Collection<OduSwitchingPools> oduSwithcingPools = device.nonnullOduSwitchingPools().values();
             List<SwitchingPoolLcp> switchingPoolList = new ArrayList<>();
             for (OduSwitchingPools odp : oduSwithcingPools) {
-                List<NonBlockingList> nblList = new ArrayList<>();
+                Map<NonBlockingListKey,NonBlockingList> nbMap = new HashMap<>();
                 for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org
-                    .openroadm.device.odu.switching.pools.NonBlockingList nbl : odp.getNonBlockingList()) {
+                    .openroadm.device.odu.switching.pools.NonBlockingList nbl : odp.nonnullNonBlockingList().values()) {
                     List<String> lcpList = new ArrayList<>();
                     if (nbl.getPortList() != null) {
-                        for (PortList item : nbl.getPortList()) {
+                        for (PortList item : nbl.nonnullPortList().values()) {
                             String key = item.getCircuitPackName() + "+" + item.getPortName();
                             if (lcpMap.containsKey(key)) {
                                 lcpList.add(lcpMap.get(key));
@@ -470,13 +474,13 @@ public class PortMappingVersion221 {
                             .setInterconnectBandwidthUnit(nbl.getInterconnectBandwidthUnit())
                             .setLcpList(lcpList)
                             .build();
-                        nblList.add(nonBlockingList);
+                        nbMap.put(nonBlockingList.key(),nonBlockingList);
                     }
                 }
                 SwitchingPoolLcp splBldr = new SwitchingPoolLcpBuilder()
                     .setSwitchingPoolNumber(odp.getSwitchingPoolNumber())
                     .setSwitchingPoolType(odp.getSwitchingPoolType())
-                    .setNonBlockingList(nblList)
+                    .setNonBlockingList(nbMap)
                     .build();
                 switchingPoolList.add(splBldr);
             }
@@ -534,7 +538,7 @@ public class PortMappingVersion221 {
                 LogicalDatastoreType.OPERATIONAL, srgIID,
                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
             if (ordmSrgObject.isPresent()) {
-                srgCps.addAll(ordmSrgObject.get().getCircuitPacks());
+                srgCps.addAll(ordmSrgObject.get().nonnullCircuitPacks().values());
                 cpPerSrg.put(ordmSrgObject.get().getSrgNumber().toJava(), srgCps);
             }
         }
@@ -564,7 +568,7 @@ public class PortMappingVersion221 {
                     LOG.warn("{} : Circuit pack {} not found or without ports.", nodeId, circuitPackName);
                     continue;
                 }
-                List<Ports> portList = new ArrayList<>(circuitPackObject.get().getPorts());
+                List<Ports> portList = new ArrayList<>(circuitPackObject.get().nonnullPorts().values());
                 Collections.sort(portList, new SortPort221ByName());
                 int portIndex = 1;
                 for (Ports port : portList) {
@@ -718,7 +722,8 @@ public class PortMappingVersion221 {
                 LogicalDatastoreType.OPERATIONAL, deviceIID,
                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
             if (ordmDegreeObject.isPresent()) {
-                conPortMap.put(degreeCounter, ordmDegreeObject.get().getConnectionPorts());
+                conPortMap.put(degreeCounter, new ArrayList<>(ordmDegreeObject.get()
+                        .nonnullConnectionPorts().values()));
             }
         }
         LOG.info("Device {} has {} degree", deviceId, conPortMap.size());
@@ -735,7 +740,7 @@ public class PortMappingVersion221 {
             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (protocolObject.isPresent() && protocolObject.get().augmentation(Protocols1.class).getLldp() != null) {
             Lldp lldp = protocolObject.get().augmentation(Protocols1.class).getLldp();
-            for (PortConfig portConfig : lldp.getPortConfig()) {
+            for (PortConfig portConfig : lldp.nonnullPortConfig().values()) {
                 if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) {
                     InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                         .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
@@ -771,7 +776,7 @@ public class PortMappingVersion221 {
         for (Degree degree : degrees) {
             if (degree.getCircuitPacks() != null) {
                 LOG.info("Inside CP to degree list");
-                cpToDegreeList.addAll(degree.getCircuitPacks().stream()
+                cpToDegreeList.addAll(degree.nonnullCircuitPacks().values().stream()
                     .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
                         degree.getDegreeNumber().toString(), nodeId, interfaceList))
                     .collect(Collectors.toList()));
@@ -799,19 +804,39 @@ public class PortMappingVersion221 {
             nodesBldr.setNodeInfo(nodeInfo);
         }
         if (portMapList != null) {
-            nodesBldr.setMapping(portMapList);
+            Map<MappingKey, Mapping> mappingMap = new HashMap<>();
+            for (Mapping mapping: portMapList) {
+                if (mapping != null) {
+                    mappingMap.put(mapping.key(), mapping);
+                }
+            }
+            nodesBldr.setMapping(mappingMap);
         }
         if (cp2DegreeList != null) {
-            nodesBldr.setCpToDegree(cp2DegreeList);
+            Map<CpToDegreeKey, CpToDegree> cpToDegreeMap = new HashMap<>();
+            for (CpToDegree cp2Degree: cp2DegreeList) {
+                if (cp2Degree != null) {
+                    cpToDegreeMap.put(cp2Degree.key(), cp2Degree);
+                }
+            }
+            nodesBldr.setCpToDegree(cpToDegreeMap);
         }
+
         if (splList != null) {
-            nodesBldr.setSwitchingPoolLcp(splList);
+            Map<SwitchingPoolLcpKey,SwitchingPoolLcp> splMap = new HashMap<>();
+            for (SwitchingPoolLcp spl: splList) {
+                if (spl != null) {
+                    splMap.put(spl.key(), spl);
+                }
+            }
+            nodesBldr.setSwitchingPoolLcp(splMap);
         }
         if (mcCapList != null) {
             nodesBldr.setMcCapabilities(mcCapList);
         }
-        List<Nodes> nodesList = new ArrayList<>();
-        nodesList.add(nodesBldr.build());
+        Map<NodesKey,Nodes> nodesList = new HashMap<>();
+        Nodes nodes = nodesBldr.build();
+        nodesList.put(nodes.key(),nodes);
 
         NetworkBuilder nwBldr = new NetworkBuilder().setNodes(nodesList);
 

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfaceException.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfaceException.java
index 200c27282366539e37e846f82f1d930c66977b04..4da6970112595cb4558512d6ceea389e5b64a100 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfaceException.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfaceException.java
@@ -8,6 +8,9 @@
 
 package org.opendaylight.transportpce.common.openroadminterfaces;
 
+@edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+    value = "SE_NO_SERIALVERSIONID",
+    justification = "https://github.com/rzwitserloot/lombok/wiki/WHY-NOT:-serialVersionUID")
 public class OpenRoadmInterfaceException extends Exception {
 
     public OpenRoadmInterfaceException(String message) {

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl121.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl121.java
index 56decc1cc31201e320cdefd15d49c5a75180b25b..d7637fd01dd4431f9a4d170b875a577896da5b42 100755 (executable)
--- a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl121.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl121.java
@@ -110,7 +110,7 @@ public class OpenRoadmInterfacesImpl121 {
                     odu.setMaintTestsignal(maintSignalBuilder.build());
                 }
                 oduBuilder.setOdu(odu.build());
-                ifBuilder.addAugmentation(Interface1.class, oduBuilder.build());
+                ifBuilder.addAugmentation(oduBuilder.build());
             } else if (ifBuilder.getType() == OtnOtu.class) {
                 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder
                     otuBuilder =
@@ -125,9 +125,7 @@ public class OpenRoadmInterfacesImpl121 {
                     otu.setMaintLoopback(maintLoopBackBuilder.build());
                 }
                 otuBuilder.setOtu(otu.build());
-                ifBuilder.addAugmentation(
-                    org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class,
-                    otuBuilder.build());
+                ifBuilder.addAugmentation(otuBuilder.build());
             }
             ifBuilder.setAdministrativeState(AdminStates.OutOfService);
             // post interface with updated admin state

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
index 150b8fd6317679ecf796358d644c77a71b417767..a0c0d56655f8f687f6ef6b7c5f048d041357628b 100755 (executable)
--- a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
@@ -113,7 +113,7 @@ public class OpenRoadmInterfacesImpl221 {
                     odu.setMaintTestsignal(maintSignalBuilder.build());
                 }
                 oduBuilder.setOdu(odu.build());
-                ifBuilder.addAugmentation(Interface1.class, oduBuilder.build());
+                ifBuilder.addAugmentation(oduBuilder.build());
             } else if (ifBuilder.getType() == OtnOtu.class) {
                 org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder
                     otuBuilder =
@@ -128,9 +128,7 @@ public class OpenRoadmInterfacesImpl221 {
                     otu.setMaintLoopback(maintLoopBackBuilder.build());
                 }
                 otuBuilder.setOtu(otu.build());
-                ifBuilder.addAugmentation(
-                    org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1.class,
-                    otuBuilder.build());
+                ifBuilder.addAugmentation(otuBuilder.build());
             }
             ifBuilder.setAdministrativeState(AdminStates.OutOfService);
             // post interface with updated admin state

diff --git a/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java b/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java
index 735a57dd949c33eaa1d51acbf424fb90ef973190..f08e6f498cd858b61dd6dd9843b43f59c3c28cb4 100644 (file)
--- a/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java
+++ b/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java
@@ -11,7 +11,6 @@ package org.opendaylight.transportpce.common.device;
 import static org.mockito.ArgumentMatchers.any;
 
 import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.LinkedList;
@@ -300,16 +299,6 @@ public class DeviceTransactionManagerTest {
     @Test
     @Ignore
     public void submitTxTimeoutTransactionTest() {
-        ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
-        Mockito.when(rwTransactionMock.commit()).then(invocation -> Futures.makeChecked(executor.submit(() -> {
-            try {
-                Thread.sleep(3000);
-            } catch (InterruptedException e) {
-                Assert.fail("Exception catched in future! " + e);
-            }
-            return null;
-        }), input -> input));
-
         Future<java.util.Optional<DeviceTransaction>> deviceTxFuture =
                 transactionManager.getDeviceTransaction(defaultDeviceId);
         DeviceTransaction deviceTx;
@@ -351,7 +340,8 @@ public class DeviceTransactionManagerTest {
 
         Mockito.verify(rwTransactionMock, Mockito.times(2)).put(defaultDatastore, defaultIid, defaultData);
         Mockito.verify(rwTransactionMock, Mockito.times(2)).commit();
-
+        ListeningExecutorService executor = MoreExecutors
+                .listeningDecorator(Executors.newSingleThreadExecutor());
         executor.shutdown();
     }
 

diff --git a/common/src/test/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImplTest.java b/common/src/test/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImplTest.java
index 7aac85bae5421654574686e92d5b3ef2361b29ee..612c463c3e8f66532f40be5c879b3bf05e83ddea 100644 (file)
--- a/common/src/test/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImplTest.java
+++ b/common/src/test/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImplTest.java
@@ -9,7 +9,6 @@
 package org.opendaylight.transportpce.common.mapping;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 
 import java.util.concurrent.ExecutionException;
@@ -45,28 +44,30 @@ public class MappingUtilsImplTest {
         final MappingUtils mappingUtils = new MappingUtilsImpl(dataBroker);
         final NodeInfo nodeInfo = new NodeInfoBuilder().setOpenroadmVersion(NodeInfo.OpenroadmVersion._121).build();
         final NodeInfo nodeInfo2 = new NodeInfoBuilder().setOpenroadmVersion(NodeInfo.OpenroadmVersion._221).build();
-        Nodes nodes = new NodesBuilder().setNodeId("node3").build();
-        InstanceIdentifier<NodeInfo> nodeInfoIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
-                new NodesKey("node")).child(NodeInfo.class).build();
-        InstanceIdentifier<NodeInfo> nodeInfoIID2 = InstanceIdentifier.builder(Network.class).child(Nodes.class,
-                new NodesKey("node2")).child(NodeInfo.class).build();
+        Nodes nodes = new NodesBuilder().setNodeId("nodes").setNodeInfo(nodeInfo).build();
+        Nodes nodes2 = new NodesBuilder().setNodeId("nodes2").setNodeInfo(nodeInfo2).build();
+        Nodes nodes3 = new NodesBuilder().setNodeId("nodes3").build();
         InstanceIdentifier<Nodes> nodeIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
-                new NodesKey("node3")).build();
+                new NodesKey("nodes")).build();
+        InstanceIdentifier<Nodes> nodeIID2 = InstanceIdentifier.builder(Network.class).child(Nodes.class,
+                new NodesKey("nodes2")).build();
+        InstanceIdentifier<Nodes> nodeIID3 = InstanceIdentifier.builder(Network.class).child(Nodes.class,
+                new NodesKey("nodes3")).build();
         WriteTransaction wr = dataBroker.newWriteOnlyTransaction();
 
         //Create a node version 1, a node version 2, and a node no version
-        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeInfoIID, nodeInfo, true);
-        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeInfoIID2, nodeInfo2, true);
-        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeIID, nodes, true);
+        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeIID, nodes);
+        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeIID2, nodes2);
+        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeIID3, nodes3);
         wr.commit().get();
         //Test the versions are returned OK
-        assertEquals("They have the same openroadmVersion",
-                mappingUtils.getOpenRoadmVersion("node"), StringConstants.OPENROADM_DEVICE_VERSION_1_2_1);
-        assertEquals("They have the same openroadmVersion",
-                mappingUtils.getOpenRoadmVersion("node2"), StringConstants.OPENROADM_DEVICE_VERSION_2_2_1);
-        assertNull("node3 isn't exists", mappingUtils.getOpenRoadmVersion("node3"));
-        assertNotNull("node is existed", mappingUtils.getOpenRoadmVersion("node"));
-        assertNotNull("node2 is existed", mappingUtils.getOpenRoadmVersion("node2"));
+        assertEquals("NodeInfo with nodes as id should be 1.2.1 version",
+                StringConstants.OPENROADM_DEVICE_VERSION_1_2_1,
+                mappingUtils.getOpenRoadmVersion("nodes"));
+        assertEquals("NodeInfo with nodes as id should be 2.2.1 version",
+                StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+                mappingUtils.getOpenRoadmVersion("nodes2"));
+        assertNull("NodeInfo with nodes3 as id should not exist", mappingUtils.getOpenRoadmVersion("nodes3"));
     }
 
 

diff --git a/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java b/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java
index fad6107ee4537b11f8f6a18d40b837ba0ddaa281..e61f4a59a11e6c195fd0d202eb6236b2646659a8 100644 (file)
--- a/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java
+++ b/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java
@@ -28,6 +28,7 @@ import org.opendaylight.transportpce.common.DataStoreContext;
 import org.opendaylight.transportpce.common.DataStoreContextImpl;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.Network;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.NodesBuilder;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.NodesKey;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.Mapping;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.MappingBuilder;
@@ -82,19 +83,22 @@ public class PortMappingImplTest {
                 new NodesKey("node")).child(NodeInfo.class).build();
         final NodeInfo nodeInfo = new NodeInfoBuilder().setOpenroadmVersion(NodeInfo.OpenroadmVersion._221).build();
         final NodeInfo nodeInfo2 = new NodeInfoBuilder().setOpenroadmVersion(NodeInfo.OpenroadmVersion._121).build();
-
+        Nodes nodes = new NodesBuilder().setNodeId("node").setNodeInfo(nodeInfo).build();
+        InstanceIdentifier<Nodes> nodeIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
+                new NodesKey("node")).build();
         //create node with portmapping and nodeifno version 2
         WriteTransaction wr = dataBroker.newWriteOnlyTransaction();
-        wr.merge(LogicalDatastoreType.CONFIGURATION, portMappingIID, mapping, true);
-        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeInfoIID, nodeInfo, true);
+        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeIID, nodes);
+        wr.merge(LogicalDatastoreType.CONFIGURATION, portMappingIID, mapping);
+        wr.merge(LogicalDatastoreType.CONFIGURATION, nodeInfoIID, nodeInfo);
         wr.commit().get();
         //test update port mapping version 2
         when(portMappingVersion221.updateMapping("node", mapping)).thenReturn(true);
-        assertEquals(portMapping.updateMapping("node", mapping), true);
+        assertTrue("Update sould be ok", portMapping.updateMapping("node", mapping));
 
         //replace node nodefino version 1 instead of version 2
         WriteTransaction wr2 = dataBroker.newWriteOnlyTransaction();
-        wr2.put(LogicalDatastoreType.CONFIGURATION, nodeInfoIID, nodeInfo2, true);
+        wr2.merge(LogicalDatastoreType.CONFIGURATION, nodeInfoIID, nodeInfo2);
         wr2.commit().get();
 
         //test update portmapping version 1

diff --git a/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121Test.java b/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121Test.java
index 9fb7e77c8cc58a30032648773b76bcfb222f6aed..04d7f879220841df4673101badab48f61fc1a7e5 100644 (file)
--- a/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121Test.java
+++ b/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121Test.java
@@ -8,6 +8,7 @@
 
 package org.opendaylight.transportpce.common.mapping;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -18,8 +19,11 @@ import static org.mockito.Mockito.when;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.Random;
 import java.util.concurrent.ExecutionException;
 import org.eclipse.jdt.annotation.NonNull;
 import org.junit.Before;
@@ -35,6 +39,8 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa
 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.Network;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.NetworkBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.Mapping;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.Direction;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port;
@@ -47,6 +53,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPorts;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPortsBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPortsKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
@@ -54,6 +61,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.open
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDeviceBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ConnectionMap;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ConnectionMapBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ConnectionMapKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
@@ -66,19 +74,21 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.open
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.Destination;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.DestinationBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.DestinationKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.SourceBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.InterfacesBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.PartnerPortBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalTransport;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1Builder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.LldpBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfig;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfigBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfigKey;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yangtools.yang.binding.Augmentation;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.Uint16;
@@ -92,57 +102,55 @@ public class PortMappingVersion121Test {
     private static DataBroker dataBroker;
     private static DeviceTransactionManager deviceTransactionManager;
     private static OpenRoadmInterfaces openRoadmInterfaces;
-    private static  PortMappingVersion121 portMappingVersion121;
+    private static PortMappingVersion121 portMappingVersion121;
+    private Random ran = new Random();
 
     @Before
     public void setUp() throws Exception {
-        //test createMappingData for a xpdr node with 3 network + 1 client + bidirectional & unidirectional ports
+        // test createMappingData for a xpdr node with 3 network + 1 client + bidirectional & unidirectional ports
         DataStoreContext dataStoreContext = new DataStoreContextImpl();
         dataBroker = dataStoreContext.getDataBroker();
         deviceTransactionManager = mock(DeviceTransactionManager.class);
         openRoadmInterfaces = mock(OpenRoadmInterfaces.class);
-        portMappingVersion121 = new PortMappingVersion121(dataBroker,
-                deviceTransactionManager,
-                openRoadmInterfaces);
+        portMappingVersion121 = new PortMappingVersion121(dataBroker, deviceTransactionManager, openRoadmInterfaces);
     }
 
     @Test
     public void createMappingDataTestRdm() {
-        //mock node info
+        // mock node info
         final Info info = getInfo2();
 
-        List<Interfaces> interfacesList = Arrays.asList(getInterfaces("i1"),
-                getInterfaces("i2"));
+        List<Interfaces> interfacesList = Arrays.asList(getInterfaces("i1"), getInterfaces("i2"));
 
-        //mock 1 bidirectional port for degree
+        // mock 1 bidirectional port for degree
         Ports ports = getPortsWithInterfaces(interfacesList, "p1");
         List<Ports> portsList = Arrays.asList(ports);
 
-        //mock 2 bidirectional port for SRG
+        // mock 2 bidirectional port for SRG
         Ports ports1 = getPortsWithInterfaces(interfacesList, "p2");
         List<Ports> portsList1 = Arrays.asList(ports1);
 
-        //mock 2 unidirectional ports for degree
+        // mock 2 unidirectional ports for degree
         Ports ports2 = getPorts("p2", Port.PortQual.RoadmExternal, "c3", "p3", Direction.Rx);
         Ports ports3 = getPorts("p3", Port.PortQual.RoadmExternal, "c3", "p2", Direction.Tx);
-        List<Ports> portsList2 = Arrays.asList(ports2,ports3);
+        List<Ports> portsList2 = Arrays.asList(ports2, ports3);
 
-        //mock 2 unidirectional ports for degree, reverse direction
+        // mock 2 unidirectional ports for degree, reverse direction
         Ports ports22 = getPorts("p22", Port.PortQual.RoadmExternal, "c5", "p33", Direction.Tx);
         Ports ports33 = getPorts("p33", Port.PortQual.RoadmExternal, "c5", "p22", Direction.Rx);
-        List<Ports> portsList22 = Arrays.asList(ports22,ports33);
+        List<Ports> portsList22 = Arrays.asList(ports22, ports33);
 
-        //mock 2 unidirectional ports for srg
+        // mock 2 unidirectional ports for srg
         Ports ports4 = getPorts("p4", Port.PortQual.RoadmExternal, "c4", "p5", Direction.Rx);
         Ports ports5 = getPorts("p5", Port.PortQual.RoadmExternal, "c4", "p4", Direction.Tx);
-        List<Ports> portsList4 = Arrays.asList(ports4,ports5);
+        List<Ports> portsList4 = Arrays.asList(ports4, ports5);
 
-        //mock 2 unidirectional ports for srg, reverse direction
+        // mock 2 unidirectional ports for srg, reverse direction
         Ports ports44 = getPorts("p44", Port.PortQual.RoadmExternal, "c6", "p55", Direction.Tx);
         Ports ports55 = getPorts("p55", Port.PortQual.RoadmExternal, "c6", "p44", Direction.Rx);
-        List<Ports> portsList44 = Arrays.asList(ports44,ports55);
+        List<Ports> portsList44 = Arrays.asList(ports44, ports55);
 
-        //mock 6 circuit packs
+        // mock 6 circuit packs
         final CircuitPacks circuitPackObject = getCircuitPacks(portsList, "c1", "pc1");
         final CircuitPacks circuitPackObject2 = getCircuitPacks(portsList, "c2", "pc2");
         final CircuitPacks circuitPackObject3 = getCircuitPacks(portsList2, "c3", "pc3");
@@ -150,10 +158,10 @@ public class PortMappingVersion121Test {
         final CircuitPacks circuitPackObject5 = getCircuitPacks(portsList22, "c5", "pc5");
         final CircuitPacks circuitPackObject6 = getCircuitPacks(portsList44, "c6", "pc6");
 
-        //mock 6 connection ports
+        // mock 6 connection ports
         ConnectionPorts connectionPorts = getConnectionPorts("c1", "p1");
-        List<ConnectionPorts> connectionPortsList = new ArrayList<ConnectionPorts>();
-        connectionPortsList.add(connectionPorts);
+        Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap = new HashMap<>();
+        connectionPortsMap.put(connectionPorts.key(), connectionPorts);
 
         ConnectionPorts connectionPorts2 = getConnectionPorts("c2", "p1");
         List<ConnectionPorts> connectionPortsList2 = new ArrayList<ConnectionPorts>();
@@ -161,9 +169,9 @@ public class PortMappingVersion121Test {
 
         ConnectionPorts connectionPorts3 = getConnectionPorts("c3", "p2");
         ConnectionPorts connectionPorts4 = getConnectionPorts("c3", "p3");
-        List<ConnectionPorts> connectionPortsList3 = new ArrayList<ConnectionPorts>();
-        connectionPortsList3.add(connectionPorts3);
-        connectionPortsList3.add(connectionPorts4);
+        Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap3 = new HashMap<>();
+        connectionPortsMap3.put(connectionPorts3.key(), connectionPorts3);
+        connectionPortsMap3.put(connectionPorts4.key(), connectionPorts4);
 
         ConnectionPorts connectionPorts5 = getConnectionPorts("c4", "p4");
         ConnectionPorts connectionPorts6 = getConnectionPorts("c4", "p5");
@@ -173,40 +181,43 @@ public class PortMappingVersion121Test {
 
         ConnectionPorts connectionPorts33 = getConnectionPorts("c5", "p22");
         ConnectionPorts connectionPorts44 = getConnectionPorts("c5", "p33");
-        List<ConnectionPorts> connectionPortsList33 = new ArrayList<ConnectionPorts>();
-        connectionPortsList33.add(connectionPorts33);
-        connectionPortsList33.add(connectionPorts44);
+        Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap33 = new HashMap<>();
+        connectionPortsMap33.put(connectionPorts33.key(), connectionPorts33);
+        connectionPortsMap33.put(connectionPorts44.key(), connectionPorts44);
 
         ConnectionPorts connectionPorts55 = getConnectionPorts("c6", "p44");
         ConnectionPorts connectionPorts66 = getConnectionPorts("c6", "p55");
-        List<ConnectionPorts> connectionPortsList44 = new ArrayList<ConnectionPorts>();
-        connectionPortsList44.add(connectionPorts55);
-        connectionPortsList44.add(connectionPorts66);
+        Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap44 = new HashMap<>();
+        connectionPortsMap44.put(connectionPorts55.key(), connectionPorts55);
+        connectionPortsMap44.put(connectionPorts66.key(), connectionPorts66);
 
-
-        //mock one degree with bidirectional port
+        // mock one degree with bidirectional port
         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks circuitPacks =
                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksBuilder()
                         .setCircuitPackName("c1").build();
-        List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> circuitPacksList =
-                new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks>();
-        circuitPacksList.add(circuitPacks);
+        Map<
+                org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey,
+                org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> circuitPacksMap =
+                        new HashMap<>();
+        circuitPacksMap.put(circuitPacks.key(), circuitPacks);
 
         final Degree ordmDegreeObject = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(1))
-                .setCircuitPacks(circuitPacksList).setConnectionPorts(connectionPortsList).build();
+                .setCircuitPacks(circuitPacksMap).setConnectionPorts(connectionPortsMap).build();
 
-        //mock one srg with bidirectional port
+        // mock one srg with bidirectional port
         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks srgCircuitPacks =
                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksBuilder()
                         .setCircuitPackName("c2").build();
-        List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCircuitPacksList =
-                new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks>();
-        srgCircuitPacksList.add(srgCircuitPacks);
+        Map<
+                org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksKey,
+                org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCircuitPacksList =
+                        new HashMap<>();
+        srgCircuitPacksList.put(srgCircuitPacks.key(), srgCircuitPacks);
 
         final SharedRiskGroup ordmSrgObject = new SharedRiskGroupBuilder().setSrgNumber(Uint16.valueOf(1))
                 .setCircuitPacks(srgCircuitPacksList).build();
 
-        //mock one degree with 2 unidirectional ports
+        // mock one degree with 2 unidirectional ports
         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks circuitPacks3 =
                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksBuilder()
                         .setCircuitPackName("c3").build();
@@ -214,103 +225,109 @@ public class PortMappingVersion121Test {
                 new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks>();
         circuitPacksList3.add(circuitPacks3);
 
-        final Degree ordmDegreeObject3 = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(2))
-                .setCircuitPacks(circuitPacksList3).setConnectionPorts(connectionPortsList3).build();
-
-        //mock one srg with 2 unidirectional ports
+        Map<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey,
+            org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> values =
+            new HashMap<>();
+        org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey circuitPackKey =
+                new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey(
+                        Uint32.valueOf(3));
+        values.put(circuitPackKey, circuitPacks3);
+        final Degree ordmDegreeObject3 = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(2)).setCircuitPacks(values)
+                .setConnectionPorts(connectionPortsMap3).build();
+        // mock one srg with 2 unidirectional ports
         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks srgCircuitPacks4 =
                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksBuilder()
                         .setCircuitPackName("c4").build();
-        List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCircuitPacksList4 =
-                new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks>();
-        srgCircuitPacksList4.add(srgCircuitPacks4);
+        Map<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksKey,
+                org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks>
+            srgCircuitPacksList4 = new HashMap<>();
+        srgCircuitPacksList4.put(srgCircuitPacks4.key(), srgCircuitPacks4);
 
         final SharedRiskGroup ordmSrgObject4 = new SharedRiskGroupBuilder().setSrgNumber(Uint16.valueOf(2))
                 .setCircuitPacks(srgCircuitPacksList4).build();
 
-        //mock one degree with unidirectional ports, reverse direction
+        // mock one degree with unidirectional ports, reverse direction
         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks circuitPacks5 =
                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksBuilder()
                         .setCircuitPackName("c5").build();
         List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> circuitPacksList5 =
                 new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks>();
         circuitPacksList5.add(circuitPacks5);
-
-        final Degree ordmDegreeObject5 = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(3))
-                .setCircuitPacks(circuitPacksList5).setConnectionPorts(connectionPortsList33).build();
-
-        //mock one srg with 2 unidirectional ports, reverse direction
+        values = new HashMap<>();
+        circuitPackKey = new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey(
+                Uint32.valueOf(5));
+        values.put(circuitPackKey, circuitPacks5);
+        final Degree ordmDegreeObject5 = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(3)).setCircuitPacks(values)
+                .setConnectionPorts(connectionPortsMap44).build();
+
+        // mock one srg with 2 unidirectional ports, reverse direction
         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks srgCircuitPacks6 =
                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksBuilder()
                         .setCircuitPackName("c6").build();
-        List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCircuitPacksList6 =
-                new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks>();
-        srgCircuitPacksList6.add(srgCircuitPacks6);
+        Map<
+                org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksKey,
+                org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCircuitPacksMap6 =
+                        new HashMap<>();
+        srgCircuitPacksMap6.put(srgCircuitPacks6.key(), srgCircuitPacks6);
 
         final SharedRiskGroup ordmSrgObject6 = new SharedRiskGroupBuilder().setSrgNumber(Uint16.valueOf(3))
-                .setCircuitPacks(srgCircuitPacksList6).build();
-
-        //mock lldp configuration
-        PortConfig portConfig = new PortConfigBuilder().setIfName("i1")
-                .setAdminStatus(PortConfig.AdminStatus.Txandrx).build();
-        List<PortConfig> portConfigList = new ArrayList<PortConfig>();
-        portConfigList.add(portConfig);
-
-        Protocols protocols =
-                new ProtocolsBuilder().addAugmentation(Protocols1.class, new Protocols1Builder()
-                        .setLldp(new LldpBuilder().setPortConfig(portConfigList).build()).build()).build();
-
-        //mock responses for deviceTransactionManager calls
-        InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm
-                .device.container.org.openroadm.device.Degree> deviceIID =
-                InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                        .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm
-                                .device.container.org.openroadm.device.Degree.class, new DegreeKey(1));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, deviceIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ordmDegreeObject));
-
-        InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm
-                .device.container.org.openroadm.device.Degree> deviceIID3 =
-                InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                        .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm
-                                .device.container.org.openroadm.device.Degree.class, new DegreeKey(2));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, deviceIID3,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ordmDegreeObject3));
-
-        InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm
-                .device.container.org.openroadm.device.Degree> deviceIID5 =
-                InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                        .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm
-                                .device.container.org.openroadm.device.Degree.class, new DegreeKey(3));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, deviceIID5,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ordmDegreeObject5));
-
-        InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(Protocols.class);
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, protocoliid,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(protocols));
+                .setCircuitPacks(srgCircuitPacksMap6).build();
+
+        // mock lldp configuration
+        PortConfig portConfig =
+                new PortConfigBuilder().setIfName("i1").setAdminStatus(PortConfig.AdminStatus.Txandrx).build();
+        Map<PortConfigKey, PortConfig> portConfigMap = new HashMap<>();
+        portConfigMap.put(portConfig.key(), portConfig);
+        Augmentation<Protocols> augmentation =
+                new Protocols1Builder().setLldp(new LldpBuilder().setPortConfig(portConfigMap).build()).build();
+        Protocols protocols = new ProtocolsBuilder().addAugmentation(augmentation).build();
+
+        // mock responses for deviceTransactionManager calls
+        InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device
+            .rev170206.org.openroadm.device.container.org.openroadm.device.Degree> deviceIID = InstanceIdentifier
+            .create(OrgOpenroadmDevice.class)
+            .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device
+                    .rev170206.org.openroadm.device.container.org.openroadm.device.Degree.class,
+                                new DegreeKey(Uint16.valueOf(1)));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(ordmDegreeObject));
+
+        InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+            .org.openroadm.device.container.org.openroadm.device.Degree> deviceIID3 = InstanceIdentifier
+            .create(OrgOpenroadmDevice.class)
+            .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+            .org.openroadm.device.container.org.openroadm.device.Degree.class,
+                                new DegreeKey(Uint16.valueOf(2)));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID3,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(ordmDegreeObject3));
+
+        InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+            .org.openroadm.device.container.org.openroadm.device.Degree> deviceIID5 = InstanceIdentifier
+            .create(OrgOpenroadmDevice.class)
+            .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+            .org.openroadm.device.container.org.openroadm.device.Degree.class,
+                                new DegreeKey(Uint16.valueOf(3)));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID5,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(ordmDegreeObject5));
+
+        InstanceIdentifier<Protocols> protocoliid =
+                InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Protocols.class);
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, protocoliid,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(protocols));
 
         Interface interfaceObject = new InterfaceBuilder().setSupportingCircuitPackName("sc1").build();
         InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, interfaceIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(interfaceObject));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, interfaceIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(interfaceObject));
 
         InstanceIdentifier<Ports> portID = getChild("c1", "p1");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports));
 
         InstanceIdentifier<Ports> portID1 = getChild("c2", "p1");
         when(deviceTransactionManager.getDataFromDevice("node",
@@ -319,141 +336,110 @@ public class PortMappingVersion121Test {
             .thenReturn(Optional.of(ports1));
 
         InstanceIdentifier<Ports> portID2 = getChild("c3", "p2");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID2,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports2));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID2,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports2));
 
         InstanceIdentifier<Ports> portID3 = getChild("c3", "p3");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID3,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports3));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID3,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports3));
 
         InstanceIdentifier<Ports> portID22 = getChild("c5", "p22");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID22,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports22));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID22,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports22));
 
         InstanceIdentifier<Ports> portID33 = getChild("c5", "p33");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID33,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports33));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID33,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports33));
 
         InstanceIdentifier<Ports> portID4 = getChild("c4", "p4");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID4,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports4));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID4,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports4));
 
         InstanceIdentifier<Ports> portID5 = getChild("c4", "p5");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID5,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports5));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID5,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports5));
 
         InstanceIdentifier<Ports> portID44 = getChild("c6", "p44");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID44, Timeouts.DEVICE_READ_TIMEOUT,
-                    Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports44));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID44,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports44));
 
         InstanceIdentifier<Ports> portID55 = getChild("c6", "p55");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID55,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports55));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID55,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports55));
 
         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, infoIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(info));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, infoIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(info));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c1"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID2 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c2"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID2,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject2));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID2,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject2));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID3 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c3"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID3,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject3));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID3,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject3));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID4 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c4"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID4,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject4));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID4,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject4));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID5 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c5"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID5,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject5));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID5,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject5));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID6 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c6"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID6,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject6));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID6,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject6));
 
         InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(SharedRiskGroup.class, new SharedRiskGroupKey(1));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, srgIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ordmSrgObject));
+                .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(1)));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, srgIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(ordmSrgObject));
 
         InstanceIdentifier<SharedRiskGroup> srgIID4 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(SharedRiskGroup.class, new SharedRiskGroupKey(2));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, srgIID4,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ordmSrgObject4));
+                .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(2)));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, srgIID4,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(ordmSrgObject4));
 
         InstanceIdentifier<SharedRiskGroup> srgIID6 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(SharedRiskGroup.class, new SharedRiskGroupKey(3));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, srgIID6,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ordmSrgObject6));
-
-        Interface ifc1 = new InterfaceBuilder()
-                .setType(OpticalTransport.class).build();
-        Interface ifc2 = new InterfaceBuilder()
-                .setType(OpenROADMOpticalMultiplex.class).build();
+                .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(3)));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, srgIID6,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(ordmSrgObject6));
+
+        Interface ifc1 = new InterfaceBuilder().setType(OpticalTransport.class).build();
+        Interface ifc2 = new InterfaceBuilder().setType(OpenROADMOpticalMultiplex.class).build();
         try {
-            when(openRoadmInterfaces.getInterface("node", "i1"))
-                    .thenReturn(Optional.of(ifc1));
-            when(openRoadmInterfaces.getInterface("node", "i2"))
-                    .thenReturn(Optional.of(ifc2));
+            when(openRoadmInterfaces.getInterface("node", "i1")).thenReturn(Optional.of(ifc1));
+            when(openRoadmInterfaces.getInterface("node", "i2")).thenReturn(Optional.of(ifc2));
         } catch (OpenRoadmInterfaceException e) {
             LOG.error("Failed to mock interafce.", e);
             fail();
         }
 
-        //test createMappingData with a node with 3 dgree + 3 srg + bidirectional & unidirectional ports
+        // test createMappingData with a node with 3 dgree + 3 srg + bidirectional & unidirectional ports
         assertTrue("creating mappingdata for existed node returns true",
                 portMappingVersion121.createMappingData("node"));
 
-        //verify 2 interfaces were processed
+        // verify 2 interfaces were processed
         try {
             verify(openRoadmInterfaces).getInterface("node", "i1");
             verify(openRoadmInterfaces).getInterface("node", "i2");
@@ -462,14 +448,12 @@ public class PortMappingVersion121Test {
             fail();
         }
 
-        //assert all portmappings have been created for the roadm node
+        // assert all portmappings have been created for the roadm node
         ReadTransaction rr = dataBroker.newReadOnlyTransaction();
-        InstanceIdentifier<Network> mappingIID =
-                InstanceIdentifier.create(Network.class);
+        InstanceIdentifier<Network> mappingIID = InstanceIdentifier.create(Network.class);
         Network network = new NetworkBuilder().build();
         try {
-            Optional<Network> optionalNetwork =
-                    rr.read(LogicalDatastoreType.CONFIGURATION, mappingIID).get();
+            Optional<Network> optionalNetwork = rr.read(LogicalDatastoreType.CONFIGURATION, mappingIID).get();
             if (optionalNetwork.isPresent()) {
                 network = optionalNetwork.get();
             }
@@ -479,114 +463,100 @@ public class PortMappingVersion121Test {
             fail();
 
         }
-        List<String> testMappings = new ArrayList<>(List.of("SRG2-PP1-RX", "SRG3-PP1-RX", "SRG1-PP1-TXRX",
-            "SRG3-PP1-TX", "DEG1-TTP-TXRX", "SRG2-PP1-TX", "DEG2-TTP-RX", "DEG2-TTP-TX", "DEG3-TTP-RX", "DEG3-TTP-TX"));
+        List<String> testMappings = Arrays.asList("SRG2-PP1-RX", "SRG3-PP1-RX", "SRG1-PP1-TXRX", "SRG3-PP1-TX",
+                "DEG1-TTP-TXRX", "SRG2-PP1-TX", "DEG2-TTP-RX", "DEG2-TTP-TX", "DEG3-TTP-RX", "DEG3-TTP-TX");
         List<String> mappings = new ArrayList<>();
+        List<Nodes> nodes = new ArrayList<>(network.nonnullNodes().values());
+        List<Mapping> mappingValues = new ArrayList<>(nodes.get(0).nonnullMapping().values());
         for (int i = 0; i < testMappings.size(); i++) {
-            mappings.add(network.getNodes().get(0).getMapping().get(i).getLogicalConnectionPoint());
+            mappings.add(mappingValues.get(i).getLogicalConnectionPoint());
         }
         Collections.sort(testMappings);
         Collections.sort(mappings);
-        assertTrue("test mapping are equals to mapping" , testMappings.equals(mappings));
+        assertEquals("test mapping are equals to mapping", testMappings, mappings);
 
-        //test updateMapping
-        assertTrue("update mapping for node returns true", portMappingVersion121
-                .updateMapping("node", network.getNodes().get(0).getMapping().get(0)));
+        // test updateMapping
+        assertTrue("update mapping for node returns true",
+                portMappingVersion121.updateMapping("node", mappingValues.get(0)));
 
-        //test createMapping for non-existent roadm node
-        assertFalse("create non existed roadm node returns false" ,
-                portMappingVersion121.createMappingData("node2"));
+        // test createMapping for non-existent roadm node
+        assertFalse("create non existed roadm node returns false", portMappingVersion121.createMappingData("node2"));
 
-        //test updateMapping for null roadm node
+        // test updateMapping for null roadm node
         assertFalse("updating null roadm node returns false",
-                portMappingVersion121.updateMapping(null, network.getNodes().get(0).getMapping().get(0)));
+                portMappingVersion121.updateMapping(null, mappingValues.get(0)));
 
     }
 
     @Test
     public void createMappingDataTestXpdr() {
-        //mock node info
+        // mock node info
         final Info info = getInfo();
 
-        //mock 1 bidirectional port for network
+        // mock 1 bidirectional port for network
         Ports ports = new PortsBuilder().setPortName("p1").setPortQual(Port.PortQual.XpdrNetwork)
                 .setPortDirection(Direction.Bidirectional).build();
         List<Ports> portsList = new ArrayList<>();
         portsList.add(ports);
 
-        //mock 1 bidirectional port for client
+        // mock 1 bidirectional port for client
         Ports ports11 = new PortsBuilder().setPortName("p11").setPortQual(Port.PortQual.XpdrClient)
                 .setPortDirection(Direction.Bidirectional).build();
         List<Ports> portsList11 = new ArrayList<>();
         portsList11.add(ports11);
 
-        //mock 2 unidirectional ports for network
+        // mock 2 unidirectional ports for network
         Ports ports2 = getPorts("p2", Port.PortQual.XpdrNetwork, "c3", "p3", Direction.Rx);
         Ports ports3 = getPorts("p3", Port.PortQual.XpdrNetwork, "c3", "p2", Direction.Tx);
         List<Ports> portsList2 = new ArrayList<>();
         portsList2.add(ports2);
         portsList2.add(ports3);
 
-
-        //mock 2 unidirectional ports for network, reverse direction
+        // mock 2 unidirectional ports for network, reverse direction
         Ports ports4 = getPorts("p4", Port.PortQual.XpdrNetwork, "c4", "p5", Direction.Tx);
         Ports ports5 = getPorts("p5", Port.PortQual.XpdrNetwork, "c4", "p4", Direction.Rx);
         List<Ports> portsList4 = new ArrayList<>();
         portsList4.add(ports4);
         portsList4.add(ports5);
 
-        //mock connection map
+        // mock connection map
         Destination destination = new DestinationBuilder().setCircuitPackName("c2").setPortName("p11").build();
         List<Destination> destinationList = new ArrayList<>();
         destinationList.add(destination);
         ConnectionMap connectionMap = getConnectionMap(destinationList);
-        List<ConnectionMap> connectionMapList = new ArrayList<>();
-        connectionMapList.add(connectionMap);
+        Map<ConnectionMapKey, ConnectionMap> connectionMapMap = new HashMap<>();
+        connectionMapMap.put(connectionMap.key(), connectionMap);
 
-        //mock reponses for deviceTransactionManager
+        // mock reponses for deviceTransactionManager
         InstanceIdentifier<Ports> portID = getChild("c1", "p1");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports));
 
         InstanceIdentifier<Ports> portID11 = getChild("c2", "p11");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID11,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports11));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID11,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports11));
 
         InstanceIdentifier<Ports> portID2 = getChild("c3", "p2");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID2,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports2));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID2,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports2));
 
         InstanceIdentifier<Ports> portID3 = getChild("c3", "p3");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID3,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports3));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID3,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports3));
 
         InstanceIdentifier<Ports> portID4 = getChild("c4", "p4");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID4,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports4));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID4,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports4));
 
         InstanceIdentifier<Ports> portID5 = getChild("c4", "p5");
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, portID5,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(ports5));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID5,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports5));
 
         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, infoIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(info));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, infoIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(info));
 
-        //mock 4 circuit packs
+        // mock 4 circuit packs
         CircuitPacks circuitPackObject = getCircuitPacks(portsList, "c1", "pc1");
         CircuitPacks circuitPackObject2 = getCircuitPacks(portsList11, "c2", "pc2");
         CircuitPacks circuitPackObject3 = getCircuitPacks(portsList2, "c3", "pc3");
@@ -594,56 +564,49 @@ public class PortMappingVersion121Test {
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c1"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID2 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c2"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID2,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject2));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID2,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject2));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID3 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c3"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID3,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject3));
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID3,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject3));
 
         InstanceIdentifier<CircuitPacks> circuitPacksIID4 = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(CircuitPacks.class, new CircuitPacksKey("c4"));
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, circuitPacksIID4,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(circuitPackObject4));
-
-
-        List<CircuitPacks> circuitPackArrayList = Arrays.asList(circuitPackObject, circuitPackObject2,
-                circuitPackObject3, circuitPackObject4);
-
-        OrgOpenroadmDevice deviceObject = new OrgOpenroadmDeviceBuilder().setCircuitPacks(circuitPackArrayList)
-                .setConnectionMap(connectionMapList).build();
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID4,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+                        .thenReturn(Optional.of(circuitPackObject4));
+
+        Map<CircuitPacksKey, CircuitPacks> circuitPacksMap = new HashMap<>();
+        circuitPacksMap.put(circuitPackObject.key(), circuitPackObject);
+        circuitPacksMap.put(circuitPackObject2.key(), circuitPackObject2);
+        circuitPacksMap.put(circuitPackObject3.key(), circuitPackObject3);
+        circuitPacksMap.put(circuitPackObject4.key(), circuitPackObject4);
+
+        OrgOpenroadmDevice deviceObject = new OrgOpenroadmDeviceBuilder().setCircuitPacks(circuitPacksMap)
+                .setConnectionMap(connectionMapMap).build();
         InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
-        when(deviceTransactionManager.getDataFromDevice("node",
-                    LogicalDatastoreType.OPERATIONAL, deviceIID,
-                    Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
-                .thenReturn(Optional.of(deviceObject));
-
+        when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID,
+                Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(deviceObject));
 
-        //test createMappingData for xpdr node with 2 network + 1 client + unidirectional & bidirectional ports
+        // test createMappingData for xpdr node with 2 network + 1 client + unidirectional & bidirectional ports
         assertTrue("returns true when create mapping ", portMappingVersion121.createMappingData("node"));
 
-        //assert all portmappings have been created for the xpdr node
+        // assert all portmappings have been created for the xpdr node
         ReadTransaction rr = dataBroker.newReadOnlyTransaction();
-        InstanceIdentifier<Network> mappingIID =
-                InstanceIdentifier.create(Network.class);
+        InstanceIdentifier<Network> mappingIID = InstanceIdentifier.create(Network.class);
         Network network = new NetworkBuilder().build();
         try {
-            Optional<Network> optionalNetwork =
-                    rr.read(LogicalDatastoreType.CONFIGURATION, mappingIID).get();
+            Optional<Network> optionalNetwork = rr.read(LogicalDatastoreType.CONFIGURATION, mappingIID).get();
             if (optionalNetwork.isPresent()) {
                 network = optionalNetwork.get();
             }
@@ -655,34 +618,36 @@ public class PortMappingVersion121Test {
         List<String> testMappings = new ArrayList<>(List.of("XPDR1-CLIENT1", "XPDR1-NETWORK5", "XPDR1-NETWORK4",
             "XPDR1-NETWORK3", "XPDR1-NETWORK2", "XPDR1-NETWORK1"));
         List<String> mappings = new ArrayList<>();
+        List<Nodes> nodes = new ArrayList<>(network.nonnullNodes().values());
+        List<Mapping> mappingValues = new ArrayList<>(nodes.get(0).nonnullMapping().values());
         for (int i = 0; i < testMappings.size(); i++) {
-            mappings.add(network.getNodes().get(0).getMapping().get(i).getLogicalConnectionPoint());
+            mappings.add(mappingValues.get(i).getLogicalConnectionPoint());
         }
         Collections.sort(testMappings);
         Collections.sort(mappings);
-        assertTrue("test mapping are equals to mapping", testMappings.equals(mappings));
-
+        assertEquals("test mapping are equals to mapping", testMappings, mappings);
     }
 
     @NonNull
     private KeyedInstanceIdentifier<Ports, PortsKey> getChild(String c4, String p5) {
-        return InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(CircuitPacks.class, new CircuitPacksKey(c4))
+        return InstanceIdentifier.create(OrgOpenroadmDevice.class).child(CircuitPacks.class, new CircuitPacksKey(c4))
                 .child(Ports.class, new PortsKey(p5));
     }
 
     private ConnectionMap getConnectionMap(List<Destination> destinationList) {
+        Map<DestinationKey, Destination> destinationMap = new HashMap<>();
+        for (Destination destination : destinationList) {
+            destinationMap.put(destination.key(), destination);
+        }
         return new ConnectionMapBuilder().setConnectionMapNumber(Uint32.valueOf(1))
                 .setSource(new SourceBuilder().setCircuitPackName("c1").setPortName("p1").build())
-                .setDestination(destinationList).build();
+                .setDestination(destinationMap).build();
     }
 
     private Info getInfo() {
-        return new InfoBuilder().setNodeNumber(Uint32.valueOf(1)).setClli("clli")
-                .setNodeType(NodeTypes.Xpdr).setModel("model").setVendor("vendor")
-                .setIpAddress(new IpAddress(new Ipv4Address("10.1.1.1")))
-                .setMaxDegrees(Uint16.valueOf(2)).setMaxSrgs(Uint16.valueOf(2))
-                .setNodeId("node").build();
+        return new InfoBuilder().setNodeNumber(Uint32.valueOf(1)).setClli("clli").setNodeType(NodeTypes.Xpdr)
+                .setModel("model").setVendor("vendor").setIpAddress(new IpAddress(new Ipv4Address("10.1.1.1")))
+                .setMaxDegrees(Uint16.valueOf(2)).setMaxSrgs(Uint16.valueOf(2)).setNodeId("node").build();
     }
 
     private Ports getPorts(String p2, Port.PortQual roadmExternal, String c3, String p3, Direction rx) {
@@ -692,27 +657,29 @@ public class PortMappingVersion121Test {
     }
 
     private ConnectionPorts getConnectionPorts(String c1, String p1) {
-        return new ConnectionPortsBuilder().setCircuitPackName(c1).setPortName(p1).build();
+        return new ConnectionPortsBuilder().setIndex(Uint32.valueOf(ran.nextInt(Integer.MAX_VALUE)))
+                .setCircuitPackName(c1).setPortName(p1).build();
     }
 
     private CircuitPacks getCircuitPacks(List<Ports> portsList, String c1, String pc1) {
+        Map<PortsKey, Ports> portsMap = new HashMap<>();
+        for (Ports ports : portsList) {
+            portsMap.put(ports.key(), ports);
+        }
         return new CircuitPacksBuilder().setCircuitPackName(c1)
-                .setParentCircuitPack(new ParentCircuitPackBuilder()
-                        .setCircuitPackName(pc1).build()).setPorts(portsList).build();
+                .setParentCircuitPack(new ParentCircuitPackBuilder().setCircuitPackName(pc1).build()).setPorts(portsMap)
+                .build();
     }
 
-
     private Ports getPortsWithInterfaces(List<Interfaces> interfacesList, String p1) {
         return new PortsBuilder().setPortName(p1).setPortQual(Port.PortQual.RoadmExternal)
                 .setPortDirection(Direction.Bidirectional).setInterfaces(interfacesList).build();
     }
 
     private Info getInfo2() {
-        return new InfoBuilder().setNodeNumber(Uint32.valueOf(1)).setClli("clli")
-                .setNodeType(NodeTypes.Rdm).setModel("model").setVendor("vendor")
-                .setIpAddress(new IpAddress(new Ipv4Address("10.1.1.1")))
-                .setMaxDegrees(Uint16.valueOf(3)).setMaxSrgs(Uint16.valueOf(3))
-                .build();
+        return new InfoBuilder().setNodeNumber(Uint32.valueOf(1)).setClli("clli").setNodeType(NodeTypes.Rdm)
+                .setModel("model").setVendor("vendor").setIpAddress(new IpAddress(new Ipv4Address("10.1.1.1")))
+                .setMaxDegrees(Uint16.valueOf(3)).setMaxSrgs(Uint16.valueOf(3)).build();
     }
 
     private Interfaces getInterfaces(String i1) {