opendaylight/topologymanager/implementation/src/test/java/org/opendaylight/controller/topologymanager/internal/TopologyManagerImplTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.topologymanager.internal;
  10
  11 import java.net.InetAddress;
  12 import java.net.UnknownHostException;
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Set;
  20 import java.util.concurrent.ConcurrentMap;
  21
  22 import org.junit.Assert;
  23 import org.junit.Test;
  24 import org.opendaylight.controller.sal.core.Bandwidth;
  25 import org.opendaylight.controller.sal.core.ConstructionException;
  26 import org.opendaylight.controller.sal.core.Edge;
  27 import org.opendaylight.controller.sal.core.Host;
  28 import org.opendaylight.controller.sal.core.Latency;
  29 import org.opendaylight.controller.sal.core.Node;
  30 import org.opendaylight.controller.sal.core.Node.NodeIDType;
  31 import org.opendaylight.controller.sal.core.NodeConnector;
  32 import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType;
  33 import org.opendaylight.controller.sal.core.Property;
  34 import org.opendaylight.controller.sal.core.State;
  35 import org.opendaylight.controller.sal.core.UpdateType;
  36 import org.opendaylight.controller.sal.packet.address.EthernetAddress;
  37 import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
  38 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
  39 import org.opendaylight.controller.sal.utils.NodeCreator;
  40 import org.opendaylight.controller.sal.utils.Status;
  41 import org.opendaylight.controller.sal.utils.StatusCode;
  42 import org.opendaylight.controller.switchmanager.ISwitchManager;
  43 import org.opendaylight.controller.switchmanager.SpanConfig;
  44 import org.opendaylight.controller.switchmanager.Subnet;
  45 import org.opendaylight.controller.switchmanager.SubnetConfig;
  46 import org.opendaylight.controller.switchmanager.Switch;
  47 import org.opendaylight.controller.switchmanager.SwitchConfig;
  48 import org.opendaylight.controller.topologymanager.TopologyUserLinkConfig;
  49
  50 public class TopologyManagerImplTest {
  51     /**
  52      * Mockup of switch manager that only maintains existence of node
  53      * connector.
  54      */
  55     private final class TestSwitchManager implements ISwitchManager {
  56         private final Set<Node>  nodeSet = new HashSet<Node>();
  57         private final Set<NodeConnector> nodeConnectorSet =
  58                 new HashSet<NodeConnector>();
  59
  60         private void addNodeConnectors(NodeConnector ... connectors) {
  61             for (NodeConnector nc: connectors) {
  62                 if (nc != null) {
  63                     nodeSet.add(nc.getNode());
  64                     nodeConnectorSet.add(nc);
  65                 }
  66             }
  67         }
  68
  69         private void addNodeConnectors(TopologyUserLinkConfig ... links) {
  70             for (TopologyUserLinkConfig link: links) {
  71                 NodeConnector src =
  72                         NodeConnector.fromString(link.getSrcNodeConnector());
  73                 NodeConnector dst =
  74                         NodeConnector.fromString(link.getDstNodeConnector());
  75                 addNodeConnectors(src, dst);
  76             }
  77         }
  78
  79         @Override
  80         public Status addSubnet(SubnetConfig configObject) {
  81             return null;
  82         }
  83
  84         @Override
  85         public Status removeSubnet(SubnetConfig configObject) {
  86             return null;
  87         }
  88
  89         @Override
  90         public Status modifySubnet(SubnetConfig configObject) {
  91             return null;
  92         }
  93
  94         @Override
  95         public Status removeSubnet(String name) {
  96             return null;
  97         }
  98
  99         @Override
 100         public List<Switch> getNetworkDevices() {
 101             return null;
 102         }
 103
 104         @Override
 105         public List<SubnetConfig> getSubnetsConfigList() {
 106             return null;
 107         }
 108
 109         @Override
 110         public SubnetConfig getSubnetConfig(String subnet) {
 111             return null;
 112         }
 113
 114         @Override
 115         public Subnet getSubnetByNetworkAddress(InetAddress networkAddress) {
 116             return null;
 117         }
 118
 119         @Override
 120         public Status saveSwitchConfig() {
 121             return null;
 122         }
 123
 124         @Override
 125         public Status addSpanConfig(SpanConfig configObject) {
 126             return null;
 127         }
 128
 129         @Override
 130         public Status removeSpanConfig(SpanConfig cfgObject) {
 131             return null;
 132         }
 133
 134         @Override
 135         public List<SpanConfig> getSpanConfigList() {
 136             return null;
 137         }
 138
 139         @Override
 140         public List<NodeConnector> getSpanPorts(Node node) {
 141             return null;
 142         }
 143
 144         @Override
 145         public void updateSwitchConfig(SwitchConfig cfgObject) {
 146         }
 147
 148         @Override
 149         public Status updateNodeConfig(SwitchConfig switchConfig) {
 150             return null;
 151         }
 152
 153         @Override
 154         public Status removeNodeConfig(String nodeId) {
 155             return null;
 156         }
 157
 158         @Override
 159         public SwitchConfig getSwitchConfig(String nodeId) {
 160             return null;
 161         }
 162
 163         @Override
 164         public Status addPortsToSubnet(String name, List<String> nodeConnectors) {
 165             return null;
 166         }
 167
 168         @Override
 169         public Status removePortsFromSubnet(String name, List<String> nodeConnectors) {
 170             return null;
 171         }
 172
 173         @Override
 174         public Set<Node> getNodes() {
 175             return new HashSet<Node>(nodeSet);
 176         }
 177
 178         @Override
 179         public Map<String, Property> getNodeProps(Node node) {
 180             return new HashMap<String, Property>();
 181         }
 182
 183         @Override
 184         public Property getNodeProp(Node node, String propName) {
 185             return null;
 186         }
 187
 188         @Override
 189         public void setNodeProp(Node node, Property prop) {
 190         }
 191
 192         @Override
 193         public Status removeNodeProp(Node node, String propName) {
 194             return null;
 195         }
 196
 197         @Override
 198         public Status removeNodeAllProps(Node node) {
 199             return null;
 200         }
 201
 202         @Override
 203         public Set<NodeConnector> getUpNodeConnectors(Node node) {
 204             return getNodeConnectors(node);
 205         }
 206
 207         @Override
 208         public Set<NodeConnector> getNodeConnectors(Node node) {
 209             Set<NodeConnector> set = new HashSet<NodeConnector>();
 210             for (NodeConnector nc: nodeConnectorSet) {
 211                 if (nc.getNode().equals(node)) {
 212                     set.add(nc);
 213                 }
 214             }
 215
 216             return set;
 217         }
 218
 219         @Override
 220         public Set<NodeConnector> getPhysicalNodeConnectors(Node node) {
 221             return getNodeConnectors(node);
 222         }
 223
 224         @Override
 225         public Map<String, Property> getNodeConnectorProps(NodeConnector nodeConnector) {
 226             return new HashMap<String, Property>();
 227         }
 228
 229         @Override
 230         public Property getNodeConnectorProp(NodeConnector nodeConnector, String propName) {
 231             return null;
 232         }
 233
 234         @Override
 235         public Status addNodeConnectorProp(NodeConnector nodeConnector, Property prop) {
 236             return null;
 237         }
 238
 239         @Override
 240         public Status removeNodeConnectorProp(NodeConnector nc, String propName) {
 241             return null;
 242         }
 243
 244         @Override
 245         public Status removeNodeConnectorAllProps(NodeConnector nodeConnector) {
 246             return null;
 247         }
 248
 249         @Override
 250         public NodeConnector getNodeConnector(Node node, String nodeConnectorName) {
 251             return null;
 252         }
 253
 254         @Override
 255         public boolean isSpecial(NodeConnector p) {
 256             String type = p.getType();
 257             return (type.equals(NodeConnectorIDType.CONTROLLER)
 258                     || type.equals(NodeConnectorIDType.ALL)
 259                     || type.equals(NodeConnectorIDType.SWSTACK)
 260                     || type.equals(NodeConnectorIDType.HWPATH));
 261         }
 262
 263         @Override
 264         public Boolean isNodeConnectorEnabled(NodeConnector nodeConnector) {
 265             if (doesNodeConnectorExist(nodeConnector)) {
 266                 return Boolean.TRUE;
 267             }
 268             return Boolean.FALSE;
 269         }
 270
 271         @Override
 272         public boolean doesNodeConnectorExist(NodeConnector nc) {
 273             return (nc != null && nodeConnectorSet.contains(nc));
 274         }
 275
 276         @Override
 277         public byte[] getControllerMAC() {
 278             return new byte[6];
 279         }
 280
 281         @Override
 282         public byte[] getNodeMAC(Node node) {
 283             return new byte[6];
 284         }
 285
 286         @Override
 287         public Property createProperty(String propName, String propValue) {
 288             return null;
 289         }
 290
 291         @Override
 292         public String getNodeDescription(Node node) {
 293             return null;
 294         }
 295
 296         @Override
 297         public Status removeControllerProperty(String propertyName){
 298             return null;
 299         }
 300
 301         @Override
 302         public Set<Switch> getConfiguredNotConnectedSwitches() {
 303             // TODO Auto-generated method stub
 304             return null;
 305         }
 306
 307         @Override
 308         public Map<String, Property> getControllerProperties() {
 309             // TODO Auto-generated method stub
 310             return null;
 311         }
 312
 313         @Override
 314         public Property getControllerProperty(String propertyName) {
 315             // TODO Auto-generated method stub
 316             return null;
 317         }
 318
 319         @Override
 320         public Status setControllerProperty(Property property) {
 321             // TODO Auto-generated method stub
 322             return null;
 323         }
 324     }
 325
 326     /*
 327      * Sets the node, edges and properties for edges here: Edge <SwitchId :
 328      * NodeConnectorId> : <1:1>--><11:11>; <1:2>--><11:12>; <3:3>--><13:13>;
 329      * <3:4>--><13:14>; <5:5>--><15:15>; <5:6>--><15:16>; Method used by two
 330      * tests: testGetNodeEdges and testGetEdges
 331      *
 332      * @param topoManagerImpl
 333      *
 334      * @throws ConstructionException
 335      */
 336     public void setNodeEdges(TopologyManagerImpl topoManagerImpl, TestSwitchManager swMgr)
 337             throws ConstructionException {
 338         topoManagerImpl.nonClusterObjectCreate();
 339
 340         State state;
 341         Bandwidth bw;
 342         Latency l;
 343
 344         Set<Property> props = new HashSet<Property>();
 345         state = new State(State.EDGE_UP);
 346         bw = new Bandwidth(Bandwidth.BW100Gbps);
 347         l = new Latency(Latency.LATENCY100ns);
 348         props.add(state);
 349         props.add(bw);
 350         props.add(l);
 351
 352         for (short i = 1; i < 6; i = (short) (i + 2)) {
 353             List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
 354             NodeConnector headnc1 = NodeConnectorCreator.createOFNodeConnector(
 355                     i, NodeCreator.createOFNode((long) i));
 356             NodeConnector tailnc1 = NodeConnectorCreator
 357                     .createOFNodeConnector((short) (i + 10),
 358                             NodeCreator.createOFNode((long) (i + 10)));
 359             swMgr.addNodeConnectors(tailnc1, headnc1);
 360             Edge e1 = new Edge(tailnc1, headnc1);
 361             TopoEdgeUpdate teu1 = new TopoEdgeUpdate(e1, props,
 362                     UpdateType.ADDED);
 363             topoedgeupdateList.add(teu1);
 364
 365             NodeConnector tailnc2 = NodeConnectorCreator.createOFNodeConnector(
 366                     (short) (i + 1), headnc1.getNode());
 367             NodeConnector headnc2 = NodeConnectorCreator.createOFNodeConnector(
 368                     (short) (i + 11), tailnc1.getNode());
 369             swMgr.addNodeConnectors(tailnc1, headnc2);
 370             Edge e2 = new Edge(tailnc2, headnc2);
 371             TopoEdgeUpdate teu2 = new TopoEdgeUpdate(e2, props,
 372                     UpdateType.ADDED);
 373             topoedgeupdateList.add(teu2);
 374             topoManagerImpl.edgeUpdate(topoedgeupdateList);
 375         }
 376     }
 377
 378     @Test
 379     public void testGetNodeEdges() throws ConstructionException {
 380         TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
 381         TestSwitchManager swMgr = new TestSwitchManager();
 382         topoManagerImpl.setSwitchManager(swMgr);
 383         setNodeEdges(topoManagerImpl, swMgr);
 384
 385         Map<Node, Set<Edge>> nodeEdgeMap = topoManagerImpl.getNodeEdges();
 386         for (Iterator<Map.Entry<Node, Set<Edge>>> i = nodeEdgeMap.entrySet()
 387                 .iterator(); i.hasNext();) {
 388             Map.Entry<Node, Set<Edge>> entry = i.next();
 389             Node node = entry.getKey();
 390             Long nodeId = ((Long) node.getID()).longValue();
 391             Assert.assertTrue((node.getType().equals(NodeIDType.OPENFLOW)));
 392
 393             Set<Edge> edges = entry.getValue();
 394             for (Edge edge : edges) {
 395                 Long headNcId = ((Short) edge.getHeadNodeConnector().getID())
 396                         .longValue();
 397                 Long tailNcId = ((Short) edge.getTailNodeConnector().getID())
 398                         .longValue();
 399                 Assert.assertTrue(
 400                         (headNcId.equals(nodeId) && tailNcId.equals(nodeId + 10))
 401                         || (headNcId.equals(nodeId + 11) && tailNcId.equals(nodeId + 1))
 402                         || (headNcId.equals(nodeId + 1) && tailNcId.equals(nodeId - 9))
 403                         || (headNcId.equals(nodeId - 10) && tailNcId.equals(nodeId))
 404                         );
 405             }
 406             i.remove();
 407         }
 408         Assert.assertTrue(nodeEdgeMap.isEmpty());
 409     }
 410
 411     @Test
 412     public void testGetEdges() throws ConstructionException {
 413         TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
 414         TestSwitchManager swMgr = new TestSwitchManager();
 415         topoManagerImpl.setSwitchManager(swMgr);
 416         setNodeEdges(topoManagerImpl, swMgr);
 417
 418         Map<Edge, Set<Property>> edgeProperty = topoManagerImpl.getEdges();
 419
 420         for (Iterator<Map.Entry<Edge, Set<Property>>> i = edgeProperty
 421                 .entrySet().iterator(); i.hasNext();) {
 422             Map.Entry<Edge, Set<Property>> entry = i.next();
 423             Edge e = entry.getKey();
 424             NodeConnector headnc = e.getHeadNodeConnector();
 425             NodeConnector tailnc = e.getTailNodeConnector();
 426
 427             Long headNodeId = (Long) headnc.getNode().getID();
 428
 429             Long headNcId = ((Short) headnc.getID()).longValue();
 430             Long tailNcId = ((Short) tailnc.getID()).longValue();
 431
 432             if (headNodeId == 1 || headNodeId == 3 || headNodeId == 5) {
 433                 Assert.assertTrue((headNcId.equals(headNodeId) && tailNcId
 434                         .equals(headNodeId + 10))
 435                         || (headNcId.equals(headNodeId + 10) && tailNcId
 436                                 .equals(headNodeId))
 437                                 || (headNcId.equals(headNodeId + 1) && tailNcId
 438                                         .equals(headNodeId + 11))
 439                                         || (headNcId.equals(headNodeId + 11) && tailNcId
 440                                                 .equals(headNodeId + 1)));
 441             } else if (headNodeId == 11 || headNodeId == 13 || headNodeId == 15) {
 442                 Assert.assertTrue((headNcId.equals(headNodeId) && tailNcId
 443                         .equals(headNodeId - 10))
 444                         || (headNcId.equals(headNodeId) && tailNcId
 445                                 .equals(headNodeId - 10))
 446                                 || (headNcId.equals(headNodeId - 9) && tailNcId
 447                                         .equals(headNodeId + 1))
 448                                         || (headNcId.equals(headNodeId + 1) && tailNcId
 449                                                 .equals(headNodeId - 9)));
 450             }
 451
 452             Set<Property> prop = entry.getValue();
 453             for (Property p : prop) {
 454                 String pName;
 455                 long pValue;
 456                 if (p instanceof Bandwidth) {
 457                     Bandwidth b = (Bandwidth) p;
 458                     pName = Bandwidth.BandwidthPropName;
 459                     pValue = b.getValue();
 460                     Assert.assertTrue(pName.equals(p.getName())
 461                             && pValue == Bandwidth.BW100Gbps);
 462                     continue;
 463                 }
 464                 if (p instanceof Latency) {
 465                     Latency l = (Latency) p;
 466                     pName = Latency.LatencyPropName;
 467                     pValue = l.getValue();
 468                     Assert.assertTrue(pName.equals(p.getName())
 469                             && pValue == Latency.LATENCY100ns);
 470                     continue;
 471                 }
 472                 if (p instanceof State) {
 473                     State state = (State) p;
 474                     pName = State.StatePropName;
 475                     pValue = state.getValue();
 476                     Assert.assertTrue(pName.equals(p.getName())
 477                             && pValue == State.EDGE_UP);
 478                     continue;
 479                 }
 480             }
 481             i.remove();
 482         }
 483         Assert.assertTrue(edgeProperty.isEmpty());
 484     }
 485
 486     @Test
 487     public void testAddDeleteUserLink() {
 488         TopologyUserLinkConfig link1 = new TopologyUserLinkConfig("default1",
 489                 "OF|1@OF|2", "OF|1@OF|3");
 490         TopologyUserLinkConfig link2 = new TopologyUserLinkConfig("default1",
 491                 "OF|10@OF|20", "OF|10@OF|30");
 492         TopologyUserLinkConfig link3 = new TopologyUserLinkConfig("default2",
 493                 "OF|1@OF|2", "OF|1@OF|3");
 494         TopologyUserLinkConfig link4 = new TopologyUserLinkConfig("default20",
 495                 "OF|10@OF|20", "OF|10@OF|30");
 496
 497         TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
 498         TestSwitchManager swMgr = new TestSwitchManager();
 499         topoManagerImpl.setSwitchManager(swMgr);
 500         topoManagerImpl.nonClusterObjectCreate();
 501
 502         swMgr.addNodeConnectors(link1, link2, link3, link4);
 503
 504         Assert.assertTrue(topoManagerImpl.addUserLink(link1).isSuccess());
 505         Assert.assertTrue(topoManagerImpl.addUserLink(link2).getCode() == StatusCode.CONFLICT);
 506         Assert.assertTrue(topoManagerImpl.addUserLink(link3).getCode() == StatusCode.CONFLICT);
 507         Assert.assertTrue(topoManagerImpl.addUserLink(link4).isSuccess());
 508
 509         Assert.assertTrue(topoManagerImpl.deleteUserLink(null).getCode() == StatusCode.BADREQUEST);
 510         Assert.assertTrue(topoManagerImpl.deleteUserLink(link1.getName())
 511                 .isSuccess());
 512         Assert.assertTrue(topoManagerImpl.deleteUserLink(link4.getName())
 513                 .isSuccess());
 514         Assert.assertTrue(topoManagerImpl.getUserLinks().isEmpty());
 515
 516         TopologyUserLinkConfig badlink1 =
 517                 new TopologyUserLinkConfig("bad1", "OF|1@OF|4", "OF|1@OF|5");
 518         TopologyUserLinkConfig badlink2 =
 519                 new TopologyUserLinkConfig("bad2", "OF|10@OF|7", "OF|7@OF|13");
 520         Assert.assertEquals(StatusCode.NOTFOUND,
 521                 topoManagerImpl.addUserLink(badlink1).getCode());
 522         Assert.assertEquals(StatusCode.NOTFOUND,
 523                 topoManagerImpl.addUserLink(badlink2).getCode());
 524     }
 525
 526     @Test
 527     public void testGetUserLink() {
 528         TopologyUserLinkConfig[] link = new TopologyUserLinkConfig[5];
 529         TopologyUserLinkConfig[] reverseLink = new TopologyUserLinkConfig[5];
 530         TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
 531         TestSwitchManager swMgr = new TestSwitchManager();
 532         topoManagerImpl.setSwitchManager(swMgr);
 533         topoManagerImpl.nonClusterObjectCreate();
 534
 535         String name = "Test";
 536         String srcSwitchId = null;
 537         String srcNodeConnectorIDType = null;
 538         String srcPort = null;
 539         String srcNodeIDType = null;
 540         String dstNodeIDType = null;
 541         String dstSwitchId = null;
 542         String dstNodeConnectorIDType = null;
 543         String dstPort = null;
 544         String srcNodeConnector = null;
 545         String dstNodeConnector = null;
 546
 547         /* Creating userlinks and checking for their validity */
 548         link[0] = new TopologyUserLinkConfig(name, srcNodeConnector, dstNodeConnector);
 549         Assert.assertTrue(link[0].isValid() == false);
 550
 551         srcNodeConnector = "OF|1@OF|1";
 552         link[0] = new TopologyUserLinkConfig(name, srcNodeConnector, dstNodeConnector);
 553         Assert.assertTrue(link[0].isValid() == false);
 554
 555         dstNodeConnector = "OF|1@OF|2";
 556         link[0] = new TopologyUserLinkConfig(name, srcNodeConnector, dstNodeConnector);
 557         Assert.assertTrue(link[0].isValid() == true);
 558
 559         Integer i;
 560
 561         for (i = 0; i < 5; i++) {
 562             link[i] = new TopologyUserLinkConfig();
 563
 564             name = Integer.toString(i + 1);
 565             srcSwitchId = Integer.toString(i + 1);
 566             srcPort = Integer.toString(i + 1);
 567             dstSwitchId = Integer.toString((i + 1) * 10);
 568             dstPort = Integer.toString((i + 1) * 10);
 569
 570             link[i].setName(name);
 571             srcNodeConnectorIDType = dstNodeConnectorIDType = "INCORRECT";
 572             srcNodeConnector = srcNodeConnectorIDType+"|"+srcSwitchId+"@"+srcNodeConnectorIDType+"|"+srcPort;
 573             dstNodeConnector = dstNodeConnectorIDType+"|"+dstSwitchId+"@"+dstNodeConnectorIDType+"|"+dstPort;
 574
 575             link[i].setSrcNodeConnector(srcNodeConnector);
 576             Assert.assertTrue(link[i].isValid() == false);
 577
 578             srcNodeConnectorIDType = "OF";
 579             srcNodeConnector = srcNodeConnectorIDType+"|"+srcSwitchId+"@"+srcNodeConnectorIDType+"|"+srcPort;
 580             link[i].setSrcNodeConnector(srcNodeConnector);
 581             Assert.assertTrue(link[i].isValid() == false);
 582
 583             dstNodeConnectorIDType = "OF";
 584             dstNodeConnector = dstNodeConnectorIDType+"|"+dstSwitchId+"@"+dstNodeConnectorIDType+"|"+dstPort;
 585             link[i].setDstNodeConnector(dstNodeConnector);
 586             Assert.assertTrue(link[i].isValid() == true);
 587
 588             reverseLink[i] = new TopologyUserLinkConfig(name, dstNodeConnector, srcNodeConnector);
 589
 590             Assert.assertEquals(StatusCode.NOTFOUND,
 591                     topoManagerImpl.addUserLink(link[i]).getCode());
 592             swMgr.addNodeConnectors(link[i]);
 593             Assert.assertTrue(topoManagerImpl.addUserLink(link[i]).isSuccess());
 594         }
 595
 596         ConcurrentMap<String, TopologyUserLinkConfig> userLinks = topoManagerImpl
 597                 .getUserLinks();
 598         TopologyUserLinkConfig resultLink;
 599
 600         for (i = 0; i < 5; i++) {
 601             resultLink = userLinks.get(((Integer) (i + 1)).toString());
 602
 603             Assert.assertTrue(resultLink.getName().equals(
 604                     reverseLink[i].getName()));
 605             Assert.assertTrue(resultLink.getDstNodeConnector().equals(
 606                     reverseLink[i].getSrcNodeConnector()));
 607             Assert.assertTrue(resultLink.getSrcNodeConnector().equals(
 608                     reverseLink[i].getDstNodeConnector()));
 609         }
 610     }
 611
 612     @Test
 613     public void testHostLinkMethods() throws ConstructionException,
 614     UnknownHostException {
 615         TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
 616         TestSwitchManager swMgr = new TestSwitchManager();
 617         topoManagerImpl.setSwitchManager(swMgr);
 618         topoManagerImpl.nonClusterObjectCreate();
 619         int hostCounter = 0;
 620
 621         State state;
 622         Bandwidth bw;
 623         Latency l;
 624         Set<Property> props = new HashSet<Property>();
 625         state = new State(State.EDGE_UP);
 626         bw = new Bandwidth(Bandwidth.BW100Gbps);
 627         l = new Latency(Latency.LATENCY100ns);
 628         props.add(state);
 629         props.add(bw);
 630         props.add(l);
 631
 632         EthernetAddress ea;
 633         InetAddress ip;
 634         Host[] h = new Host[5];
 635         NodeConnector[] nc = new NodeConnector[5];
 636
 637         /*
 638          * Adding host, nodeConnector to hostsDB for the i = 0,1,2,3. No host
 639          * added for i = 4
 640          */
 641         for (int i = 0; i < 5; i++) {
 642             if (hostCounter < 4) {
 643                 ea = new EthernetAddress(new byte[] { (byte) 0x0, (byte) 0x0,
 644                         (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) i });
 645                 String stringIP = new StringBuilder().append(i + 1).append(".")
 646                         .append(i + 10).append(".").append(i + 20).append(".")
 647                         .append(i + 30).toString();
 648                 ip = InetAddress.getByName(stringIP);
 649                 h[hostCounter] = new Host(ea, ip);
 650             } else {
 651                 h[hostCounter] = null;
 652             }
 653             hostCounter++;
 654             nc[i] = NodeConnectorCreator.createOFNodeConnector((short) (i + 1),
 655                     NodeCreator.createOFNode((long) (i + 1)));
 656             topoManagerImpl
 657             .updateHostLink(nc[i], h[i], UpdateType.ADDED, props);
 658         }
 659
 660         for (int i = 0; i < 5; i++) {
 661             Host host = topoManagerImpl.getHostAttachedToNodeConnector(nc[i]);
 662             if (i == 4) {
 663                 Assert.assertTrue(host == null);
 664             } else {
 665                 Assert.assertTrue(host.equals(h[i]));
 666             }
 667         }
 668
 669         Set<NodeConnector> ncSet = topoManagerImpl.getNodeConnectorWithHost();
 670         for (int i = 0; i < 5; i++) {
 671             Assert.assertTrue(ncSet.remove(nc[i]));
 672         }
 673         Assert.assertTrue(ncSet.isEmpty());
 674     }
 675
 676     @Test
 677     public void testGetNodesWithNodeConnectorHost()
 678             throws ConstructionException, UnknownHostException {
 679         TopologyManagerImpl topoManagerImpl = new TopologyManagerImpl();
 680         TestSwitchManager swMgr = new TestSwitchManager();
 681         topoManagerImpl.setSwitchManager(swMgr);
 682         topoManagerImpl.nonClusterObjectCreate();
 683         int hostCounter = 0;
 684
 685         State state;
 686         Bandwidth bw;
 687         Latency l;
 688         Set<Property> props = new HashSet<Property>();
 689         state = new State(State.EDGE_UP);
 690         bw = new Bandwidth(Bandwidth.BW100Gbps);
 691         l = new Latency(Latency.LATENCY100ns);
 692         props.add(state);
 693         props.add(bw);
 694         props.add(l);
 695
 696         EthernetAddress ea;
 697         InetAddress ip;
 698         Host[] h = new Host[5];
 699         NodeConnector[] nc = new NodeConnector[5];
 700
 701         /*
 702          * Adding host, nodeconnector, properties of edge to hostsDB for the
 703          * first three nodes only
 704          */
 705         for (int i = 1; i < 6; i++) {
 706             if (i < 4) {
 707                 ea = new EthernetAddress(new byte[] { (byte) 0x0, (byte) 0x0,
 708                         (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) i });
 709                 String stringIP = new StringBuilder().append(i).append(".")
 710                         .append(i + 10).append(".").append(i + 20).append(".")
 711                         .append(i + 30).toString();
 712                 ip = InetAddress.getByName(stringIP);
 713                 h[hostCounter] = new Host(ea, ip);
 714             } else {
 715                 h[hostCounter] = null;
 716             }
 717             hostCounter++;
 718             nc[i - 1] = NodeConnectorCreator.createOFNodeConnector((short) i,
 719                     NodeCreator.createOFNode((long) i));
 720             topoManagerImpl.updateHostLink(nc[i - 1], h[i - 1],
 721                     UpdateType.ADDED, props);
 722         }
 723
 724         /* Get the nodes which have host connected to its nodeConnector */
 725         Map<Node, Set<NodeConnector>> nodeNCmap = topoManagerImpl
 726                 .getNodesWithNodeConnectorHost();
 727         for (int i = 1; i < 6; i++) {
 728             Node node = nc[i - 1].getNode();
 729             Set<NodeConnector> ncSet = nodeNCmap.get(nc[i - 1].getNode());
 730
 731             Assert.assertTrue(ncSet == nodeNCmap.remove(node));
 732         }
 733
 734         Assert.assertTrue(nodeNCmap.isEmpty());
 735     }
 736 }