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