opendaylight/routing/dijkstra_implementation/src/test/java/org/opendaylight/controller/routing/dijkstra_implementation/MaxThruputTest.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 package org.opendaylight.controller.routing.dijkstra_implementation;
  11
  12 import org.junit.Test;
  13
  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.utils.NodeConnectorCreator;
  20 import org.opendaylight.controller.sal.utils.NodeCreator;
  21 import java.util.LinkedList;
  22 import java.util.List;
  23 import java.util.HashMap;
  24 import java.util.Map;
  25
  26 import org.junit.Assert;
  27 import org.opendaylight.controller.routing.dijkstra_implementation.internal.DijkstraImplementation;
  28
  29 import org.opendaylight.controller.sal.core.UpdateType;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 public class MaxThruputTest {
  34     protected static final Logger logger = LoggerFactory
  35     .getLogger(MaxThruputTest.class);
  36     Map<Edge, Number> LinkCostMap = new HashMap<Edge, Number>();
  37
  38     @Test
  39     public void testMaxThruPut() {
  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         Node node4 = NodeCreator.createOFNode((long) 4);
  46         Node node5 = NodeCreator.createOFNode((long) 5);
  47         Node node6 = NodeCreator.createOFNode((long) 6);
  48         NodeConnector nc11 = NodeConnectorCreator.createOFNodeConnector(
  49                 (short) 1, node1);
  50         NodeConnector nc21 = NodeConnectorCreator.createOFNodeConnector(
  51                 (short) 1, node2);
  52         NodeConnector nc31 = NodeConnectorCreator.createOFNodeConnector(
  53                 (short) 1, node3);
  54         NodeConnector nc41 = NodeConnectorCreator.createOFNodeConnector(
  55                 (short) 1, node4);
  56         NodeConnector nc51 = NodeConnectorCreator.createOFNodeConnector(
  57                 (short) 1, node5);
  58         NodeConnector nc61 = NodeConnectorCreator.createOFNodeConnector(
  59                 (short) 1, node6);
  60         NodeConnector nc12 = NodeConnectorCreator.createOFNodeConnector(
  61                 (short) 2, node1);
  62         NodeConnector nc22 = NodeConnectorCreator.createOFNodeConnector(
  63                 (short) 2, node2);
  64         NodeConnector nc32 = NodeConnectorCreator.createOFNodeConnector(
  65                 (short) 2, node3);
  66         NodeConnector nc42 = NodeConnectorCreator.createOFNodeConnector(
  67                 (short) 2, node4);
  68         NodeConnector nc52 = NodeConnectorCreator.createOFNodeConnector(
  69                 (short) 2, node5);
  70         NodeConnector nc62 = NodeConnectorCreator.createOFNodeConnector(
  71                 (short) 2, node6);
  72
  73         Edge edge1 = null;
  74         try {
  75             edge1 = new Edge(nc11, nc21);
  76         } catch (ConstructionException e) {
  77             logger.error("",e);
  78         }
  79         LinkCostMap.put(edge1, 10);
  80         Edge edge2 = null;
  81         try {
  82             edge2 = new Edge(nc21, nc11);
  83         } catch (ConstructionException e) {
  84             logger.error("",e);
  85         }
  86         LinkCostMap.put(edge2, 10);
  87
  88         Edge edge3 = null;
  89         try {
  90             edge3 = new Edge(nc22, nc31);
  91         } catch (ConstructionException e) {
  92             logger.error("",e);
  93         }
  94         LinkCostMap.put(edge3, 30);
  95         Edge edge4 = null;
  96         try {
  97             edge4 = new Edge(nc31, nc22);
  98         } catch (ConstructionException e) {
  99             logger.error("",e);
 100         }
 101         LinkCostMap.put(edge4, 30);
 102
 103         Edge edge5 = null;
 104         try {
 105             edge5 = new Edge(nc32, nc41);
 106         } catch (ConstructionException e) {
 107             logger.error("",e);
 108         }
 109         LinkCostMap.put(edge5, 10);
 110         Edge edge6 = null;
 111         try {
 112             edge6 = new Edge(nc41, nc32);
 113         } catch (ConstructionException e) {
 114             logger.error("",e);
 115         }
 116         LinkCostMap.put(edge6, 10);
 117
 118         Edge edge7 = null;
 119         try {
 120             edge7 = new Edge(nc12, nc51);
 121         } catch (ConstructionException e) {
 122             logger.error("",e);
 123         }
 124         LinkCostMap.put(edge7, 20);
 125         Edge edge8 = null;
 126         try {
 127             edge8 = new Edge(nc51, nc12);
 128         } catch (ConstructionException e) {
 129             logger.error("",e);
 130         }
 131         LinkCostMap.put(edge8, 20);
 132
 133         Edge edge9 = null;
 134         try {
 135             edge9 = new Edge(nc52, nc61);
 136         } catch (ConstructionException e) {
 137             logger.error("",e);
 138         }
 139         LinkCostMap.put(edge9, 20);
 140         Edge edge10 = null;
 141         try {
 142             edge10 = new Edge(nc61, nc52);
 143         } catch (ConstructionException e) {
 144             logger.error("",e);
 145         }
 146         LinkCostMap.put(edge10, 20);
 147
 148         Edge edge11 = null;
 149         try {
 150             edge11 = new Edge(nc62, nc42);
 151         } catch (ConstructionException e) {
 152             logger.error("",e);
 153         }
 154         LinkCostMap.put(edge11, 20);
 155         Edge edge12 = null;
 156         try {
 157             edge12 = new Edge(nc42, nc62);
 158         } catch (ConstructionException e) {
 159             logger.error("",e);
 160         }
 161         LinkCostMap.put(edge12, 20);
 162
 163         imp.edgeUpdate(edge1, UpdateType.ADDED, null);
 164         imp.edgeUpdate(edge2, UpdateType.ADDED, null);
 165         imp.edgeUpdate(edge3, UpdateType.ADDED, null);
 166         imp.edgeUpdate(edge4, UpdateType.ADDED, null);
 167         imp.edgeUpdate(edge5, UpdateType.ADDED, null);
 168         imp.edgeUpdate(edge6, UpdateType.ADDED, null);
 169         imp.edgeUpdate(edge7, UpdateType.ADDED, null);
 170         imp.edgeUpdate(edge8, UpdateType.ADDED, null);
 171         imp.edgeUpdate(edge9, UpdateType.ADDED, null);
 172         imp.edgeUpdate(edge10, UpdateType.ADDED, null);
 173         imp.edgeUpdate(edge11, UpdateType.ADDED, null);
 174         imp.edgeUpdate(edge12, UpdateType.ADDED, null);
 175
 176         imp.initMaxThroughput(LinkCostMap);
 177
 178         Path res = imp.getMaxThroughputRoute(node1, node3);
 179         System.out.println("Max Thruput Path between n1-n3: " + res);
 180
 181         List<Edge> expectedPath = (List<Edge>) new LinkedList<Edge>();
 182         expectedPath.add(0, edge7);
 183         expectedPath.add(1, edge9);
 184         expectedPath.add(2, edge11);
 185         expectedPath.add(3, edge6);
 186
 187         Path expectedRes = null;
 188         try {
 189             expectedRes = new Path(expectedPath);
 190         } catch (ConstructionException e) {
 191             logger.error("",e);
 192         }
 193         if (!res.equals(expectedRes)) {
 194             System.out.println("Actual Res is " + res);
 195             System.out.println("Expected Res is " + expectedRes);
 196         }
 197         Assert.assertTrue(res.equals(expectedRes));
 198
 199         res = imp.getRoute(node1, node3);
 200         System.out.println("Shortest Path between n1-n3: " + res);
 201         expectedPath.clear();
 202         expectedPath.add(0, edge1);
 203         expectedPath.add(1, edge3);
 204
 205         expectedRes = null;
 206         try {
 207             expectedRes = new Path(expectedPath);
 208         } catch (ConstructionException e) {
 209             logger.error("",e);
 210         }
 211         if (!res.equals(expectedRes)) {
 212             System.out.println("Actual Res is " + res);
 213             System.out.println("Expected Res is " + expectedRes);
 214         }
 215         Assert.assertTrue(res.equals(expectedRes));
 216     }
 217 }