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