opendaylight/routing/dijkstra_implementation/src/test/java/org/opendaylight/controller/routing/dijkstra_implementation/DijkstraTest.java

   1
   2 /*
   3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7  * and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9
  10
  11 package org.opendaylight.controller.routing.dijkstra_implementation;
  12
  13 import org.opendaylight.controller.sal.core.Bandwidth;
  14 import org.opendaylight.controller.sal.core.ConstructionException;
  15 import org.opendaylight.controller.sal.core.Edge;
  16 import org.opendaylight.controller.sal.core.Node;
  17 import org.opendaylight.controller.sal.core.NodeConnector;
  18 import org.opendaylight.controller.sal.core.Path;
  19 import org.opendaylight.controller.sal.core.Property;
  20 import org.opendaylight.controller.sal.core.UpdateType;
  21 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
  22 import org.opendaylight.controller.sal.utils.NodeCreator;
  23
  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     @Test
  39     public void testSinglePathRouteNoBw() {
  40         DijkstraImplementation imp = new DijkstraImplementation();
  41         imp.init();
  42         Node node1 = NodeCreator.createOFNode((long) 1);
  43         Node node2 = NodeCreator.createOFNode((long) 2);
  44         Node node3 = NodeCreator.createOFNode((long) 3);
  45         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
  46                 (short) 1, node1);
  47         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
  48                 (short) 1, node2);
  49         Edge edge1 = null;
  50         try {
  51             edge1 = new Edge(nc11, nc21);
  52         } catch (ConstructionException e) {
  53             logger.error("",e);
  54         }
  55         Set<Property> props = new HashSet<Property>();
  56         props.add(new Bandwidth(0));
  57         imp.edgeUpdate(edge1, UpdateType.ADDED, props);
  58         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
  59                 (short) 2, node2);
  60         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
  61                 (short) 1, node3);
  62         Edge edge2 = null;
  63         try {
  64             edge2 = new Edge(nc22, nc31);
  65         } catch (ConstructionException e) {
  66             logger.error("",e);
  67         }
  68         Set<Property> props2 = new HashSet<Property>();
  69         props.add(new Bandwidth(0));
  70         imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
  71         Path res = imp.getRoute(node1, node3);
  72
  73         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
  74         expectedPath.add(0, edge1);
  75         expectedPath.add(1, edge2);
  76         Path expectedRes = null;
  77         try {
  78             expectedRes = new Path(expectedPath);
  79         } catch (ConstructionException e) {
  80             logger.error("",e);
  81         }
  82         if (!res.equals(expectedRes)) {
  83             System.out.println("Actual Res is " + res);
  84             System.out.println("Expected Res is " + expectedRes);
  85         }
  86         Assert.assertTrue(res.equals(expectedRes));
  87     }
  88
  89     @Test
  90     public void testShortestPathRouteNoBw() {
  91         DijkstraImplementation imp = new DijkstraImplementation();
  92         imp.init();
  93         Node node1 = NodeCreator.createOFNode((long) 1);
  94         Node node2 = NodeCreator.createOFNode((long) 2);
  95         Node node3 = NodeCreator.createOFNode((long) 3);
  96         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
  97                 (short) 1, node1);
  98         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
  99                 (short) 1, node2);
 100         Edge edge1 = null;
 101         try {
 102             edge1 = new Edge(nc11, nc21);
 103         } catch (ConstructionException e) {
 104             logger.error("",e);
 105         }
 106         Set<Property> props = new HashSet<Property>();
 107         props.add(new Bandwidth(0));
 108         imp.edgeUpdate(edge1, UpdateType.ADDED, props);
 109
 110         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
 111                 (short) 2, node2);
 112         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
 113                 (short) 1, node3);
 114         Edge edge2 = null;
 115         try {
 116             edge2 = new Edge(nc22, nc31);
 117         } catch (ConstructionException e) {
 118             logger.error("",e);
 119         }
 120         Set<Property> props2 = new HashSet<Property>();
 121         props.add(new Bandwidth(0));
 122         imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
 123
 124         NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
 125                 (short) 2, node1);
 126         NodeConnector nc32 = NodeConnectorCreator.createOFNodeConnector(
 127                 (short) 2, node3);
 128         Edge edge3 = null;
 129         try {
 130             edge3 = new Edge(nc12, nc32);
 131         } catch (ConstructionException e) {
 132             logger.error("",e);
 133         }
 134         Set<Property> props3 = new HashSet<Property>();
 135         props.add(new Bandwidth(0));
 136         imp.edgeUpdate(edge3, UpdateType.ADDED, props3);
 137
 138         Path res = imp.getRoute(node1, node3);
 139
 140         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
 141         expectedPath.add(0, edge3);
 142         Path expectedRes = null;
 143         try {
 144             expectedRes = new Path(expectedPath);
 145         } catch (ConstructionException e) {
 146             logger.error("",e);
 147         }
 148         if (!res.equals(expectedRes)) {
 149             System.out.println("Actual Res is " + res);
 150             System.out.println("Expected Res is " + expectedRes);
 151         }
 152         Assert.assertTrue(res.equals(expectedRes));
 153     }
 154
 155     @Test
 156     public void testShortestPathRouteNoBwAfterLinkDelete() {
 157         DijkstraImplementation imp = new DijkstraImplementation();
 158         imp.init();
 159         Node node1 = NodeCreator.createOFNode((long) 1);
 160         Node node2 = NodeCreator.createOFNode((long) 2);
 161         Node node3 = NodeCreator.createOFNode((long) 3);
 162         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
 163                 (short) 1, node1);
 164         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
 165                 (short) 1, node2);
 166         Edge edge1 = null;
 167         try {
 168             edge1 = new Edge(nc11, nc21);
 169         } catch (ConstructionException e) {
 170             logger.error("",e);
 171         }
 172         Set<Property> props = new HashSet<Property>();
 173         props.add(new Bandwidth(0));
 174         imp.edgeUpdate(edge1, UpdateType.ADDED, props);
 175
 176         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
 177                 (short) 2, node2);
 178         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
 179                 (short) 1, node3);
 180         Edge edge2 = null;
 181         try {
 182             edge2 = new Edge(nc22, nc31);
 183         } catch (ConstructionException e) {
 184             logger.error("",e);
 185         }
 186         Set<Property> props2 = new HashSet<Property>();
 187         props.add(new Bandwidth(0));
 188         imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
 189
 190         NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
 191                 (short) 2, node1);
 192         NodeConnector nc32 = NodeConnectorCreator.createOFNodeConnector(
 193                 (short) 2, node3);
 194         Edge edge3 = null;
 195         try {
 196             edge3 = new Edge(nc12, nc32);
 197         } catch (ConstructionException e) {
 198             logger.error("",e);
 199         }
 200         Set<Property> props3 = new HashSet<Property>();
 201         props.add(new Bandwidth(0));
 202         imp.edgeUpdate(edge3, UpdateType.ADDED, props3);
 203
 204         imp.edgeUpdate(edge3, UpdateType.REMOVED, props3);
 205
 206         Path res = imp.getRoute(node1, node3);
 207         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
 208         expectedPath.add(0, edge1);
 209         expectedPath.add(1, edge2);
 210         Path expectedRes = null;
 211         try {
 212             expectedRes = new Path(expectedPath);
 213         } catch (ConstructionException e) {
 214             logger.error("",e);
 215         }
 216         if (!res.equals(expectedRes)) {
 217             System.out.println("Actual Res is " + res);
 218             System.out.println("Expected Res is " + expectedRes);
 219         }
 220         Assert.assertTrue(res.equals(expectedRes));
 221     }
 222 }