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
  33 public class DijkstraTest {
  34     @Test
  35     public void testSinglePathRouteNoBw() {
  36         DijkstraImplementation imp = new DijkstraImplementation();
  37         imp.init();
  38         Node node1 = NodeCreator.createOFNode((long) 1);
  39         Node node2 = NodeCreator.createOFNode((long) 2);
  40         Node node3 = NodeCreator.createOFNode((long) 3);
  41         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
  42                 (short) 1, node1);
  43         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
  44                 (short) 1, node2);
  45         Edge edge1 = null;
  46         try {
  47             edge1 = new Edge(nc11, nc21);
  48         } catch (ConstructionException e) {
  49             e.printStackTrace();
  50         }
  51         Set<Property> props = new HashSet<Property>();
  52         props.add(new Bandwidth(0));
  53         imp.edgeUpdate(edge1, UpdateType.ADDED, props);
  54         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
  55                 (short) 2, node2);
  56         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
  57                 (short) 1, node3);
  58         Edge edge2 = null;
  59         try {
  60             edge2 = new Edge(nc22, nc31);
  61         } catch (ConstructionException e) {
  62             e.printStackTrace();
  63         }
  64         Set<Property> props2 = new HashSet<Property>();
  65         props.add(new Bandwidth(0));
  66         imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
  67         Path res = imp.getRoute(node1, node3);
  68
  69         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
  70         expectedPath.add(0, edge1);
  71         expectedPath.add(1, edge2);
  72         Path expectedRes = null;
  73         try {
  74             expectedRes = new Path(expectedPath);
  75         } catch (ConstructionException e) {
  76             e.printStackTrace();
  77         }
  78         if (!res.equals(expectedRes)) {
  79             System.out.println("Actual Res is " + res);
  80             System.out.println("Expected Res is " + expectedRes);
  81         }
  82         Assert.assertTrue(res.equals(expectedRes));
  83     }
  84
  85     @Test
  86     public void testShortestPathRouteNoBw() {
  87         DijkstraImplementation imp = new DijkstraImplementation();
  88         imp.init();
  89         Node node1 = NodeCreator.createOFNode((long) 1);
  90         Node node2 = NodeCreator.createOFNode((long) 2);
  91         Node node3 = NodeCreator.createOFNode((long) 3);
  92         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
  93                 (short) 1, node1);
  94         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
  95                 (short) 1, node2);
  96         Edge edge1 = null;
  97         try {
  98             edge1 = new Edge(nc11, nc21);
  99         } catch (ConstructionException e) {
 100             e.printStackTrace();
 101         }
 102         Set<Property> props = new HashSet<Property>();
 103         props.add(new Bandwidth(0));
 104         imp.edgeUpdate(edge1, UpdateType.ADDED, props);
 105
 106         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
 107                 (short) 2, node2);
 108         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
 109                 (short) 1, node3);
 110         Edge edge2 = null;
 111         try {
 112             edge2 = new Edge(nc22, nc31);
 113         } catch (ConstructionException e) {
 114             e.printStackTrace();
 115         }
 116         Set<Property> props2 = new HashSet<Property>();
 117         props.add(new Bandwidth(0));
 118         imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
 119
 120         NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
 121                 (short) 2, node1);
 122         NodeConnector nc32 = NodeConnectorCreator.createOFNodeConnector(
 123                 (short) 2, node3);
 124         Edge edge3 = null;
 125         try {
 126             edge3 = new Edge(nc12, nc32);
 127         } catch (ConstructionException e) {
 128             e.printStackTrace();
 129         }
 130         Set<Property> props3 = new HashSet<Property>();
 131         props.add(new Bandwidth(0));
 132         imp.edgeUpdate(edge3, UpdateType.ADDED, props3);
 133
 134         Path res = imp.getRoute(node1, node3);
 135
 136         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
 137         expectedPath.add(0, edge3);
 138         Path expectedRes = null;
 139         try {
 140             expectedRes = new Path(expectedPath);
 141         } catch (ConstructionException e) {
 142             e.printStackTrace();
 143         }
 144         if (!res.equals(expectedRes)) {
 145             System.out.println("Actual Res is " + res);
 146             System.out.println("Expected Res is " + expectedRes);
 147         }
 148         Assert.assertTrue(res.equals(expectedRes));
 149     }
 150
 151     @Test
 152     public void testShortestPathRouteNoBwAfterLinkDelete() {
 153         DijkstraImplementation imp = new DijkstraImplementation();
 154         imp.init();
 155         Node node1 = NodeCreator.createOFNode((long) 1);
 156         Node node2 = NodeCreator.createOFNode((long) 2);
 157         Node node3 = NodeCreator.createOFNode((long) 3);
 158         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
 159                 (short) 1, node1);
 160         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
 161                 (short) 1, node2);
 162         Edge edge1 = null;
 163         try {
 164             edge1 = new Edge(nc11, nc21);
 165         } catch (ConstructionException e) {
 166             e.printStackTrace();
 167         }
 168         Set<Property> props = new HashSet<Property>();
 169         props.add(new Bandwidth(0));
 170         imp.edgeUpdate(edge1, UpdateType.ADDED, props);
 171
 172         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
 173                 (short) 2, node2);
 174         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
 175                 (short) 1, node3);
 176         Edge edge2 = null;
 177         try {
 178             edge2 = new Edge(nc22, nc31);
 179         } catch (ConstructionException e) {
 180             e.printStackTrace();
 181         }
 182         Set<Property> props2 = new HashSet<Property>();
 183         props.add(new Bandwidth(0));
 184         imp.edgeUpdate(edge2, UpdateType.ADDED, props2);
 185
 186         NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
 187                 (short) 2, node1);
 188         NodeConnector nc32 = NodeConnectorCreator.createOFNodeConnector(
 189                 (short) 2, node3);
 190         Edge edge3 = null;
 191         try {
 192             edge3 = new Edge(nc12, nc32);
 193         } catch (ConstructionException e) {
 194             e.printStackTrace();
 195         }
 196         Set<Property> props3 = new HashSet<Property>();
 197         props.add(new Bandwidth(0));
 198         imp.edgeUpdate(edge3, UpdateType.ADDED, props3);
 199
 200         imp.edgeUpdate(edge3, UpdateType.REMOVED, props3);
 201
 202         Path res = imp.getRoute(node1, node3);
 203         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
 204         expectedPath.add(0, edge1);
 205         expectedPath.add(1, edge2);
 206         Path expectedRes = null;
 207         try {
 208             expectedRes = new Path(expectedPath);
 209         } catch (ConstructionException e) {
 210             e.printStackTrace();
 211         }
 212         if (!res.equals(expectedRes)) {
 213             System.out.println("Actual Res is " + res);
 214             System.out.println("Expected Res is " + expectedRes);
 215         }
 216         Assert.assertTrue(res.equals(expectedRes));
 217     }
 218 }