opendaylight/adsal/routing/dijkstra_implementation/src/test/java/org/opendaylight/controller/routing/dijkstra_implementation/DijkstraTest.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.routing.dijkstra_implementation;
  10
  11 import org.opendaylight.controller.sal.core.Bandwidth;
  12 import org.opendaylight.controller.sal.core.ConstructionException;
  13 import org.opendaylight.controller.sal.core.Edge;
  14 import org.opendaylight.controller.sal.core.Node;
  15 import org.opendaylight.controller.sal.core.NodeConnector;
  16 import org.opendaylight.controller.sal.core.Path;
  17 import org.opendaylight.controller.sal.core.Property;
  18 import org.opendaylight.controller.sal.core.UpdateType;
  19 import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
  20 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
  21 import org.opendaylight.controller.sal.utils.NodeCreator;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashSet;
  25 import java.util.LinkedList;
  26 import java.util.List;
  27 import java.util.Set;
  28
  29 import org.junit.Assert;
  30 import org.junit.Test;
  31 import org.opendaylight.controller.routing.dijkstra_implementation.internal.DijkstraImplementation;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 public class DijkstraTest {
  36     protected static final Logger logger = LoggerFactory
  37             .getLogger(DijkstraTest.class);
  38
  39     @Test
  40     public void testSinglePathRouteNoBw() {
  41         DijkstraImplementation imp = new DijkstraImplementation();
  42         imp.init();
  43         Node node1 = NodeCreator.createOFNode((long) 1);
  44         Node node2 = NodeCreator.createOFNode((long) 2);
  45         Node node3 = NodeCreator.createOFNode((long) 3);
  46         List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
  47         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
  48                 (short) 1, node1);
  49         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
  50                 (short) 1, node2);
  51         Edge edge1 = null;
  52         try {
  53             edge1 = new Edge(nc11, nc21);
  54         } catch (ConstructionException e) {
  55             logger.error("", e);
  56         }
  57         Set<Property> props = new HashSet<Property>();
  58         props.add(new Bandwidth(0));
  59         TopoEdgeUpdate teu1 = new TopoEdgeUpdate(edge1, props, UpdateType.ADDED);
  60         topoedgeupdateList.add(teu1);
  61
  62         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
  63                 (short) 2, node2);
  64         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
  65                 (short) 1, node3);
  66         Edge edge2 = null;
  67         try {
  68             edge2 = new Edge(nc22, nc31);
  69         } catch (ConstructionException e) {
  70             logger.error("", e);
  71         }
  72         Set<Property> props2 = new HashSet<Property>();
  73         props2.add(new Bandwidth(0));
  74         TopoEdgeUpdate teu2 = new TopoEdgeUpdate(edge2, props2,
  75                 UpdateType.ADDED);
  76         topoedgeupdateList.add(teu2);
  77         imp.edgeUpdate(topoedgeupdateList);
  78         Path res = imp.getRoute(node1, node3);
  79
  80         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
  81         expectedPath.add(0, edge1);
  82         expectedPath.add(1, edge2);
  83         Path expectedRes = null;
  84         try {
  85             expectedRes = new Path(expectedPath);
  86         } catch (ConstructionException e) {
  87             logger.error("", e);
  88         }
  89         if (!res.equals(expectedRes)) {
  90             System.out.println("Actual Res is " + res);
  91             System.out.println("Expected Res is " + expectedRes);
  92         }
  93         Assert.assertTrue(res.equals(expectedRes));
  94     }
  95
  96     @Test
  97     public void testShortestPathRouteNoBw() {
  98         DijkstraImplementation imp = new DijkstraImplementation();
  99         List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
 100         imp.init();
 101         Node node1 = NodeCreator.createOFNode((long) 1);
 102         Node node2 = NodeCreator.createOFNode((long) 2);
 103         Node node3 = NodeCreator.createOFNode((long) 3);
 104         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
 105                 (short) 1, node1);
 106         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
 107                 (short) 1, node2);
 108         Edge edge1 = null;
 109         try {
 110             edge1 = new Edge(nc11, nc21);
 111         } catch (ConstructionException e) {
 112             logger.error("", e);
 113         }
 114         Set<Property> props = new HashSet<Property>();
 115         props.add(new Bandwidth(0));
 116         TopoEdgeUpdate teu1 = new TopoEdgeUpdate(edge1, props, UpdateType.ADDED);
 117         topoedgeupdateList.add(teu1);
 118
 119         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
 120                 (short) 2, node2);
 121         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
 122                 (short) 1, node3);
 123         Edge edge2 = null;
 124         try {
 125             edge2 = new Edge(nc22, nc31);
 126         } catch (ConstructionException e) {
 127             logger.error("", e);
 128         }
 129         Set<Property> props2 = new HashSet<Property>();
 130         props2.add(new Bandwidth(0));
 131         TopoEdgeUpdate teu2 = new TopoEdgeUpdate(edge2, props2,
 132                 UpdateType.ADDED);
 133         topoedgeupdateList.add(teu2);
 134
 135         NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
 136                 (short) 2, node1);
 137         NodeConnector nc32 = NodeConnectorCreator.createOFNodeConnector(
 138                 (short) 2, node3);
 139         Edge edge3 = null;
 140         try {
 141             edge3 = new Edge(nc12, nc32);
 142         } catch (ConstructionException e) {
 143             logger.error("", e);
 144         }
 145         Set<Property> props3 = new HashSet<Property>();
 146         props3.add(new Bandwidth(0));
 147         TopoEdgeUpdate teu3 = new TopoEdgeUpdate(edge3, props3,
 148                 UpdateType.ADDED);
 149         topoedgeupdateList.add(teu3);
 150         imp.edgeUpdate(topoedgeupdateList);
 151
 152         Path res = imp.getRoute(node1, node3);
 153
 154         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
 155         expectedPath.add(0, edge3);
 156         Path expectedRes = null;
 157         try {
 158             expectedRes = new Path(expectedPath);
 159         } catch (ConstructionException e) {
 160             logger.error("", e);
 161         }
 162         if (!res.equals(expectedRes)) {
 163             System.out.println("Actual Res is " + res);
 164             System.out.println("Expected Res is " + expectedRes);
 165         }
 166         Assert.assertTrue(res.equals(expectedRes));
 167     }
 168
 169     @Test
 170     public void testShortestPathRouteNoBwAfterLinkDelete() {
 171         DijkstraImplementation imp = new DijkstraImplementation();
 172         imp.init();
 173         List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
 174         Node node1 = NodeCreator.createOFNode((long) 1);
 175         Node node2 = NodeCreator.createOFNode((long) 2);
 176         Node node3 = NodeCreator.createOFNode((long) 3);
 177         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
 178                 (short) 1, node1);
 179         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
 180                 (short) 1, node2);
 181         Edge edge1 = null;
 182         try {
 183             edge1 = new Edge(nc11, nc21);
 184         } catch (ConstructionException e) {
 185             logger.error("", e);
 186         }
 187         Set<Property> props = new HashSet<Property>();
 188         props.add(new Bandwidth(0));
 189         TopoEdgeUpdate teu1 = new TopoEdgeUpdate(edge1, props, UpdateType.ADDED);
 190         topoedgeupdateList.add(teu1);
 191
 192         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
 193                 (short) 2, node2);
 194         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
 195                 (short) 1, node3);
 196         Edge edge2 = null;
 197         try {
 198             edge2 = new Edge(nc22, nc31);
 199         } catch (ConstructionException e) {
 200             logger.error("", e);
 201         }
 202         Set<Property> props2 = new HashSet<Property>();
 203         props2.add(new Bandwidth(0));
 204         TopoEdgeUpdate teu2 = new TopoEdgeUpdate(edge2, props2,
 205                 UpdateType.ADDED);
 206         topoedgeupdateList.add(teu2);
 207
 208         NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
 209                 (short) 2, node1);
 210         NodeConnector nc32 = NodeConnectorCreator.createOFNodeConnector(
 211                 (short) 2, node3);
 212         Edge edge3 = null;
 213         try {
 214             edge3 = new Edge(nc12, nc32);
 215         } catch (ConstructionException e) {
 216             logger.error("", e);
 217         }
 218         Set<Property> props3 = new HashSet<Property>();
 219         props3.add(new Bandwidth(0));
 220         TopoEdgeUpdate teu3 = new TopoEdgeUpdate(edge3, props3,
 221                 UpdateType.ADDED);
 222         topoedgeupdateList.add(teu3);
 223         TopoEdgeUpdate teu4 = new TopoEdgeUpdate(edge3, props3,
 224                 UpdateType.REMOVED);
 225         topoedgeupdateList.add(teu4);
 226
 227         imp.edgeUpdate(topoedgeupdateList);
 228
 229         Path res = imp.getRoute(node1, node3);
 230         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
 231         expectedPath.add(0, edge1);
 232         expectedPath.add(1, edge2);
 233         Path expectedRes = null;
 234         try {
 235             expectedRes = new Path(expectedPath);
 236         } catch (ConstructionException e) {
 237             logger.error("", e);
 238         }
 239         if (!res.equals(expectedRes)) {
 240             System.out.println("Actual Res is " + res);
 241             System.out.println("Expected Res is " + expectedRes);
 242         }
 243         Assert.assertTrue(res.equals(expectedRes));
 244     }
 245 }