opendaylight/adsal/forwardingrulesmanager/api/src/test/java/org/opendaylight/controller/forwardingrulesmanager/frmTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.forwardingrulesmanager;
  10
  11 import java.net.InetAddress;
  12 import java.net.UnknownHostException;
  13 import java.util.ArrayList;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Set;
  17 import java.util.concurrent.ConcurrentHashMap;
  18 import java.util.concurrent.ConcurrentMap;
  19
  20 import org.junit.Assert;
  21 import org.junit.Test;
  22 import org.opendaylight.controller.sal.action.Action;
  23 import org.opendaylight.controller.sal.action.ActionType;
  24 import org.opendaylight.controller.sal.action.Controller;
  25 import org.opendaylight.controller.sal.action.Flood;
  26 import org.opendaylight.controller.sal.action.Output;
  27 import org.opendaylight.controller.sal.action.PopVlan;
  28 import org.opendaylight.controller.sal.action.SetDlDst;
  29 import org.opendaylight.controller.sal.action.SetNwDst;
  30 import org.opendaylight.controller.sal.action.SetVlanId;
  31 import org.opendaylight.controller.sal.core.ContainerFlow;
  32 import org.opendaylight.controller.sal.core.Node;
  33 import org.opendaylight.controller.sal.core.NodeConnector;
  34 import org.opendaylight.controller.sal.flowprogrammer.Flow;
  35 import org.opendaylight.controller.sal.match.Match;
  36 import org.opendaylight.controller.sal.match.MatchType;
  37 import org.opendaylight.controller.sal.utils.EtherTypes;
  38 import org.opendaylight.controller.sal.utils.IPProtocols;
  39 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
  40 import org.opendaylight.controller.sal.utils.NodeCreator;
  41 import org.opendaylight.controller.sal.utils.Status;
  42
  43 public class frmTest {
  44
  45     @Test
  46     public void testFlowEntryInstall() throws UnknownHostException {
  47         Node node = NodeCreator.createOFNode(1L);
  48         FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
  49         FlowEntry pol2 = new FlowEntry("polTest2", null, getSampleFlowV6(node), node);
  50         FlowEntryInstall fei = new FlowEntryInstall(pol.clone(), null);
  51         FlowEntryInstall fei2 = new FlowEntryInstall(pol.clone(), null);
  52         FlowEntryInstall fei3 = new FlowEntryInstall(pol2.clone(), null);
  53         Assert.assertTrue(fei.getOriginal().equals(pol));
  54         Assert.assertTrue(fei.getInstall().equals(pol));
  55         Assert.assertTrue(fei.getFlowName().equals(pol.getFlowName()));
  56         Assert.assertTrue(fei.getGroupName().equals(pol.getGroupName()));
  57         Assert.assertTrue(fei.getNode().equals(pol.getNode()));
  58         Assert.assertFalse(fei.isDeletePending());
  59         fei.toBeDeleted();
  60         Assert.assertTrue(fei.isDeletePending());
  61         Assert.assertNull(fei.getContainerFlow());
  62         Assert.assertTrue(fei.equalsByNodeAndName(pol.getNode(), pol.getFlowName()));
  63
  64         Assert.assertTrue(fei.equals(fei2));
  65         Assert.assertFalse(fei.equals(null));
  66         Assert.assertTrue(fei.equals(fei3));
  67
  68     }
  69
  70     @Test
  71     public void testFlowEntryCreation() throws UnknownHostException {
  72         Node node = NodeCreator.createOFNode(1L);
  73         FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
  74         Assert.assertTrue(pol.getFlow().equals(getSampleFlowV6(node)));
  75     }
  76
  77     @Test
  78     public void testFlowEntrySetGet() throws UnknownHostException {
  79         Node node = NodeCreator.createOFNode(1L);
  80         Node node2 = NodeCreator.createOFNode(2L);
  81         FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
  82         pol.setGroupName("polTest2");
  83         pol.setFlowName("flowName");
  84         Assert.assertTrue(pol.getFlowName().equals("flowName"));
  85         Assert.assertTrue(pol.getGroupName().equals("polTest2"));
  86         pol.setNode(node2);
  87         Assert.assertTrue(pol.getNode().equals(node2));
  88         Assert.assertTrue(pol.equalsByNodeAndName(node2, "flowName"));
  89     }
  90
  91     @Test
  92     public void testFlowEntryEquality() throws UnknownHostException {
  93         Node node = NodeCreator.createOFNode(1L);
  94         Node node2 = NodeCreator.createOFNode(1L);
  95         FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
  96         FlowEntry pol2 = new FlowEntry("polTest", null, getSampleFlowV6(node), node2);
  97         Assert.assertTrue(pol.equals(pol2));
  98     }
  99
 100     @Test
 101     public void testFlowEntryCollision() throws UnknownHostException {
 102         // Create 2 equal FlowEntry objects
 103         Node node1 = NodeCreator.createOFNode(1L);
 104         Node node2 = NodeCreator.createOFNode(1L);
 105         FlowEntry fe1 = new FlowEntry("Junit", "flow1", getSampleFlowV6(node1), node1);
 106         FlowEntry fe2 = new FlowEntry("Junit", "flow2", getSampleFlowV6(node2), node1);
 107
 108         // Check equality in FlowEntry and parameters
 109         Assert.assertTrue(fe1.getFlow().getMatch().equals(fe2.getFlow().getMatch()));
 110         Assert.assertTrue(fe1.getFlow().getMatch().getMatches() == fe2.getFlow().getMatch().getMatches());
 111         Assert.assertTrue(fe1.getFlow().getMatch().hashCode() == fe2.getFlow().getMatch().hashCode());
 112         Assert.assertTrue(fe1.getFlow().hashCode() == fe2.getFlow().hashCode());
 113         Assert.assertTrue(fe1.equals(fe2));
 114         Assert.assertTrue(fe1.hashCode() == fe2.hashCode());
 115
 116         // Change priority field for fe2, verify inequality
 117         fe2.getFlow().setPriority((short)1000);
 118
 119         // Verify FlowEntry works as key in collection
 120         ConcurrentMap<FlowEntry, FlowEntry> map = new ConcurrentHashMap<FlowEntry, FlowEntry>();
 121         Assert.assertTrue(null == map.put(fe1, fe1));
 122         Assert.assertTrue(fe1.clone().equals(map.put(fe1.clone(), fe1.clone())));
 123         Assert.assertTrue(map.get(fe1.clone()).equals(fe1.clone()));
 124         Assert.assertTrue(map.keySet().contains(fe1.clone()));
 125         Assert.assertTrue(map.containsKey(fe1));
 126
 127         // Remove key
 128         map.remove(fe1);
 129         Assert.assertTrue(map.isEmpty());
 130         Assert.assertFalse(map.containsKey(fe1));
 131
 132         // Verify cloned object as key
 133         map.put(fe1.clone(), fe1.clone());
 134         Assert.assertTrue(map.containsKey(fe1));
 135
 136         // Verify different key is not present
 137         Assert.assertFalse(map.containsKey(fe2));
 138
 139         // Add different key
 140         map.put(fe2.clone(), fe2.clone());
 141         Assert.assertTrue(map.size() == 2);
 142         Assert.assertTrue(map.containsKey(fe1));
 143         Assert.assertTrue(map.containsKey(fe2));
 144
 145         // Make fe2 equal to fe1 again
 146         fe2.getFlow().setPriority((short)300);
 147         Assert.assertTrue(fe2.equals(fe1));
 148         Assert.assertTrue(map.containsKey(fe2));
 149
 150         // Clean up
 151         map.clear();
 152     }
 153
 154     @Test
 155     public void testFlowEntryInstallCollision() throws UnknownHostException {
 156         // Create 2 equal FlowEntryInstall objects
 157         Node node1 = NodeCreator.createOFNode(1L);
 158         Node node2 = NodeCreator.createOFNode(1L);
 159         FlowEntry fe1 = new FlowEntry("Junit", "flow1", getSampleFlowV6(node1), node1);
 160         FlowEntry fe2 = new FlowEntry("Junit", "flow2", getSampleFlowV6(node2), node1);
 161         ContainerFlow cf1 = null;
 162         ContainerFlow cf2 = null;
 163         FlowEntryInstall fei1 = new FlowEntryInstall(fe1, cf1);
 164         FlowEntryInstall fei2 = new FlowEntryInstall(fe2, cf2);
 165
 166         // Check equality in FlowEntry and parameters
 167         Assert.assertTrue(fei1.equals(fei2));
 168         Assert.assertTrue(fei1.hashCode() == fei2.hashCode());
 169
 170         // Verify FlowEntryInstall works as key in collection
 171         ConcurrentMap<FlowEntryInstall, FlowEntryInstall> map =
 172                 new ConcurrentHashMap<FlowEntryInstall, FlowEntryInstall>();
 173         Assert.assertTrue(null == map.put(fei1, fei1));
 174         Assert.assertTrue(map.get(fei1).equals(fei2));
 175         Assert.assertTrue(map.keySet().contains(fei1));
 176         Assert.assertTrue(map.keySet().contains(fei2));
 177         Assert.assertTrue(map.containsKey(fei1));
 178
 179         // Remove key
 180         map.remove(fei1);
 181         Assert.assertTrue(map.isEmpty());
 182         Assert.assertFalse(map.containsKey(fei1));
 183
 184         // Verify cloned object as key
 185         map.put(fei1, fei1);
 186         Assert.assertTrue(map.containsKey(fei1));
 187
 188         // Change fei2, change relevant hashcode info
 189         fei2.getInstall().getFlow().setPriority((short)301);
 190         Assert.assertFalse(fei1.equals(fei2));
 191         Assert.assertFalse(fei1.hashCode() == fei2.hashCode());
 192
 193
 194         // Verify different key is not present
 195         Assert.assertFalse(map.containsKey(fei2));
 196
 197         // Add different key
 198         map.put(fei2, fei2);
 199         Assert.assertTrue(map.size() == 2);
 200         Assert.assertTrue(map.containsKey(fei1));
 201         Assert.assertTrue(map.containsKey(fei2));
 202
 203         // Make fei2 equal to fei1 again
 204         fei2.getInstall().getFlow().setPriority((short)300);
 205         Assert.assertTrue(fei2.equals(fei1));
 206         Assert.assertTrue(map.containsKey(fei2));
 207
 208         // Clean up
 209         map.clear();
 210     }
 211
 212     @Test
 213     public void testFlowEntryCloning() throws UnknownHostException {
 214         Node node = NodeCreator.createOFNode(1L);
 215         FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
 216         FlowEntry pol2 = pol.clone();
 217         Assert.assertTrue(pol.equals(pol2));
 218     }
 219
 220     @Test
 221     public void testFlowEntrySet() throws UnknownHostException {
 222         Set<FlowEntry> set = new HashSet<FlowEntry>();
 223
 224         Node node1 = NodeCreator.createOFNode(1L);
 225         Node node2 = NodeCreator.createOFNode(2L);
 226         Node node3 = NodeCreator.createOFNode(3L);
 227
 228         Match match = new Match();
 229         match.setField(MatchType.NW_SRC, InetAddress.getAllByName("1.1.1.1"));
 230         match.setField(MatchType.NW_DST, InetAddress.getAllByName("2.2.2.2"));
 231         match.setField(MatchType.DL_TYPE, EtherTypes.IPv4.shortValue());
 232
 233         List<Action> actionList = new ArrayList<Action>();
 234         // actionList.add(new Drop());
 235
 236         Flow flow = new Flow(match, actionList);
 237         FlowEntry pol1 = new FlowEntry("m1", "same", flow, node1);
 238         FlowEntry pol2 = new FlowEntry("m2", "same", flow, node2);
 239         FlowEntry pol3 = new FlowEntry("m3", "same", flow, node3);
 240
 241         set.add(pol1);
 242         set.add(pol2);
 243         set.add(pol3);
 244
 245         Assert.assertTrue(set.contains(pol1));
 246         Assert.assertTrue(set.contains(pol2));
 247         Assert.assertTrue(set.contains(pol3));
 248
 249         Assert.assertTrue(set.contains(pol1.clone()));
 250         Assert.assertTrue(set.contains(pol2.clone()));
 251         Assert.assertTrue(set.contains(pol3.clone()));
 252
 253     }
 254
 255     @Test
 256     public void testInternalFlow() {
 257         FlowConfig flowConfig = new FlowConfig();
 258         Assert.assertFalse(flowConfig.isInternalFlow());
 259         flowConfig.setName("__Internal__");
 260         Status status = flowConfig.validate();
 261         Assert.assertFalse(status.isSuccess());
 262         Assert.assertTrue(status.getDescription().contains("name"));
 263         Assert.assertTrue(flowConfig.isInternalFlow());
 264         flowConfig.setName("External");
 265         Assert.assertFalse(flowConfig.isInternalFlow());
 266     }
 267
 268     @Test
 269     public void testFlowConfigCreateSet() throws UnknownHostException {
 270         FlowConfig frmC = new FlowConfig();
 271         FlowConfig frmC3 = new FlowConfig();
 272         Node node = NodeCreator.createOFNode(1L);
 273         FlowEntry entry = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
 274
 275         // testing equal function
 276         Assert.assertFalse(frmC.equals(null));
 277         Assert.assertTrue(frmC.equals(frmC));
 278         Assert.assertTrue(frmC.equals(frmC3));
 279         Assert.assertFalse(frmC.equals(entry));
 280         FlowConfig flowC = createSampleFlowConfig();
 281         Assert.assertFalse(frmC.equals(flowC));
 282         // testing installInHW
 283         Assert.assertTrue(frmC.installInHw());
 284         frmC.setInstallInHw(false);
 285         Assert.assertFalse(frmC.installInHw());
 286         frmC.setInstallInHw(true);
 287         Assert.assertTrue(frmC.installInHw());
 288
 289         // testing general set and get methods
 290         ArrayList<String> actions = createSampleActionList();
 291         frmC.setActions(actions);
 292         Assert.assertFalse(frmC.equals(frmC3));
 293         frmC3.setActions(actions);
 294
 295         Assert.assertFalse(frmC.equals(flowC));
 296         frmC.setCookie("0");
 297         Assert.assertTrue(frmC.getCookie().equals("0"));
 298         Assert.assertFalse(frmC.equals(frmC3));
 299         frmC3.setCookie("0");
 300
 301         Assert.assertFalse(frmC.equals(flowC));
 302         frmC.setDstMac("00:A0:C9:22:AB:11");
 303         Assert.assertTrue(frmC.getDstMac().equals("00:A0:C9:22:AB:11"));
 304         Assert.assertFalse(frmC.equals(frmC3));
 305         frmC3.setDstMac("00:A0:C9:22:AB:11");
 306
 307         Assert.assertFalse(frmC.equals(flowC));
 308         frmC.setSrcMac("00:A0:C9:14:C8:29");
 309         Assert.assertTrue(frmC.getSrcMac().equals("00:A0:C9:14:C8:29"));
 310         Assert.assertFalse(frmC.equals(frmC3));
 311         frmC3.setSrcMac("00:A0:C9:14:C8:29");
 312
 313         Assert.assertFalse(frmC.equals(flowC));
 314         frmC.setDynamic(true);
 315         Assert.assertTrue(frmC.isDynamic());
 316         Assert.assertFalse(frmC.equals(frmC3));
 317         frmC3.setDynamic(true);
 318         flowC.setDynamic(true);
 319
 320         Assert.assertFalse(frmC.equals(flowC));
 321         frmC.setEtherType("0x0800");
 322         Assert.assertTrue(frmC.getEtherType().equals("0x0800"));
 323         Assert.assertFalse(frmC.equals(frmC3));
 324         frmC3.setEtherType("0x0800");
 325
 326         Assert.assertFalse(frmC.equals(flowC));
 327         frmC.setIngressPort("60");
 328         Assert.assertTrue(frmC.getIngressPort().equals("60"));
 329         Assert.assertFalse(frmC.equals(frmC3));
 330         frmC3.setIngressPort("60");
 331
 332         Assert.assertFalse(frmC.equals(flowC));
 333         frmC.setName("Config1");
 334         Assert.assertTrue(frmC.getName().equals("Config1"));
 335         Assert.assertFalse(frmC.equals(frmC3));
 336         frmC3.setName("Config1");
 337
 338         Assert.assertFalse(frmC.equals(flowC));
 339         frmC.setDstIp("2.2.2.2");
 340         Assert.assertTrue(frmC.getDstIp().equals("2.2.2.2"));
 341         Assert.assertFalse(frmC.equals(frmC3));
 342         frmC3.setDstIp("2.2.2.2");
 343
 344         Assert.assertFalse(frmC.equals(flowC));
 345         frmC.setSrcIp("1.2.3.4");
 346         Assert.assertTrue(frmC.getSrcIp().equals("1.2.3.4"));
 347         Assert.assertFalse(frmC.equals(frmC3));
 348         frmC3.setSrcIp("1.2.3.4");
 349
 350         Assert.assertFalse(frmC.equals(flowC));
 351         Assert.assertFalse(frmC.isPortGroupEnabled());
 352         frmC.setPortGroup("2");
 353         Assert.assertTrue(frmC.isPortGroupEnabled());
 354         Assert.assertTrue(frmC.getPortGroup().equals("2"));
 355         Assert.assertFalse(frmC.equals(frmC3));
 356         frmC3.setPortGroup("2");
 357
 358         Assert.assertFalse(frmC.equals(flowC));
 359         frmC.setPriority("100");
 360         Assert.assertTrue(frmC.getPriority().equals("100"));
 361         Assert.assertFalse(frmC.equals(frmC3));
 362         frmC3.setPriority("100");
 363
 364         Assert.assertFalse(frmC.equals(flowC));
 365         frmC.setProtocol(IPProtocols.TCP.toString());
 366         Assert.assertTrue(frmC.getProtocol().equals(IPProtocols.TCP.toString()));
 367         Assert.assertFalse(frmC.equals(frmC3));
 368         frmC3.setProtocol(IPProtocols.TCP.toString());
 369
 370         Assert.assertFalse(frmC.equals(flowC));
 371         frmC.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
 372         Assert.assertTrue(frmC.getNode().equals(Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
 373         Assert.assertFalse(frmC.equals(frmC3));
 374         frmC3.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
 375
 376         Assert.assertFalse(frmC.equals(flowC));
 377         frmC.setTosBits("0");
 378         Assert.assertTrue(frmC.getTosBits().equals("0"));
 379         Assert.assertFalse(frmC.equals(frmC3));
 380         frmC3.setTosBits("0");
 381
 382         Assert.assertFalse(frmC.equals(flowC));
 383         frmC.setDstPort("100");
 384         Assert.assertTrue(frmC.getDstPort().equals("100"));
 385         Assert.assertFalse(frmC.equals(frmC3));
 386         frmC3.setDstPort("100");
 387
 388         Assert.assertFalse(frmC.equals(flowC));
 389         frmC.setSrcPort("8080");
 390         Assert.assertTrue(frmC.getSrcPort().equals("8080"));
 391         Assert.assertFalse(frmC.equals(frmC3));
 392         frmC3.setSrcPort("8080");
 393
 394         Assert.assertFalse(frmC.equals(flowC));
 395         frmC.setVlanId("100");
 396         Assert.assertTrue(frmC.getVlanId().equals("100"));
 397         Assert.assertFalse(frmC.equals(frmC3));
 398         frmC3.setVlanId("100");
 399
 400         Assert.assertFalse(frmC.equals(flowC));
 401         frmC.setVlanPriority("0");
 402         Assert.assertTrue(frmC.getVlanPriority().equals("0"));
 403         Assert.assertFalse(frmC.equals(frmC3));
 404         frmC3.setVlanPriority("0");
 405
 406         Assert.assertFalse(frmC.equals(flowC));
 407         frmC.setIdleTimeout("300");
 408         Assert.assertTrue(frmC.getIdleTimeout().equals("300"));
 409         Assert.assertFalse(frmC.equals(frmC3));
 410         frmC3.setIdleTimeout("300");
 411
 412         Assert.assertFalse(frmC.equals(flowC));
 413         frmC.setHardTimeout("1000");
 414         Assert.assertTrue(frmC.getHardTimeout().equals("1000"));
 415         Assert.assertFalse(frmC.equals(frmC3));
 416         frmC3.setHardTimeout("1000");
 417
 418         // Assert.assertFalse(frmC.equals(flowC));
 419         Assert.assertTrue(actions.equals(frmC.getActions()));
 420
 421         FlowConfig frmC2 = new FlowConfig(frmC);
 422
 423         Assert.assertFalse(frmC2.equals(frmC));
 424         frmC2.setDynamic(false);
 425         Assert.assertFalse(frmC2.equals(frmC));
 426         frmC2.setDynamic(true);
 427         Assert.assertTrue(frmC2.equals(frmC));
 428         // Assert.assertFalse(frmC2.equals(frmC3));
 429         flowC.setDynamic(true);
 430         Assert.assertTrue(flowC.equals(frmC));
 431         Assert.assertTrue(flowC.isStatusSuccessful());
 432         flowC.setStatus("Invalid");
 433         Assert.assertFalse(flowC.isStatusSuccessful());
 434
 435         flowC.getActions().add(ActionType.DROP.toString());
 436         Assert.assertFalse(flowC.equals(frmC));
 437         Assert.assertFalse(flowC.isIPv6());
 438         flowC.setDstIp("2001:420:281:1004:407a:57f4:4d15:c355");
 439         Assert.assertTrue(flowC.isIPv6());
 440         flowC.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
 441         Assert.assertTrue(flowC.isIPv6());
 442
 443         Long id = (Long) flowC.getNode().getID();
 444         Assert.assertTrue(id.toString().equals("1"));
 445
 446     }
 447
 448     @Test
 449     public void testFlowConfigEqualities() throws UnknownHostException {
 450         FlowConfig fc = new FlowConfig();
 451         FlowConfig fc2 = new FlowConfig();
 452         fc.setName("flow1");
 453         fc.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
 454         Assert.assertFalse(fc.onNode(Node.fromString(Node.NodeIDType.OPENFLOW, "0")));
 455         Assert.assertTrue(fc.onNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
 456
 457         Assert.assertTrue(fc.isByNameAndNodeIdEqual("flow1", Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
 458         Assert.assertFalse(fc.isByNameAndNodeIdEqual("flow1", Node.fromString(Node.NodeIDType.OPENFLOW, "0")));
 459         Assert.assertFalse(fc.isByNameAndNodeIdEqual("flow2", Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
 460
 461         Assert.assertFalse(fc.isByNameAndNodeIdEqual(fc2));
 462         fc2.setName("flow1");
 463         Assert.assertFalse(fc.isByNameAndNodeIdEqual(fc2));
 464         fc2.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "0"));
 465         Assert.assertFalse(fc.isByNameAndNodeIdEqual(fc2));
 466         fc2.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
 467         Assert.assertTrue(fc.isByNameAndNodeIdEqual(fc2));
 468     }
 469
 470     @Test
 471     public void testStatusToggle() throws UnknownHostException {
 472         // default is install in Hw
 473         FlowConfig fc = new FlowConfig();
 474         fc.toggleInstallation();
 475         Assert.assertFalse(fc.installInHw());
 476         fc.toggleInstallation();
 477         Assert.assertTrue(fc.installInHw());
 478         fc.toggleInstallation();
 479         Assert.assertFalse(fc.installInHw());
 480
 481     }
 482
 483     @Test
 484     public void testGetFlowEntry() throws UnknownHostException {
 485         FlowConfig fc2 = createSampleFlowConfig();
 486         FlowEntry fe = fc2.getFlowEntry();
 487         Assert.assertNotNull(fe);
 488     }
 489
 490     @Test
 491     public void testGetFlow() throws UnknownHostException {
 492         FlowConfig fc = new FlowConfig();
 493         fc.setActions(createSampleActionList());
 494         Flow flow = fc.getFlow();
 495         Assert.assertNotNull(flow);
 496     }
 497
 498     @Test
 499     public void testL2AddressValid() {
 500         FlowConfig fc = new FlowConfig();
 501         Assert.assertFalse(fc.isL2AddressValid(null));
 502         Assert.assertFalse(fc.isL2AddressValid("11"));
 503         Assert.assertFalse(fc.isL2AddressValid("00:A0:C9:14:C8:"));
 504         Assert.assertFalse(fc.isL2AddressValid("000:A01:C9:14:C8:211"));
 505
 506         Assert.assertTrue(fc.isL2AddressValid("00:A0:C9:14:C8:29"));
 507     }
 508
 509     @Test
 510     public void testValid() throws UnknownHostException {
 511         FlowConfig fc2 = createSampleFlowConfig();
 512         Assert.assertTrue(fc2.validate().isSuccess());
 513
 514         FlowConfig fc = new FlowConfig();
 515         Status status = fc.validate();
 516         Assert.assertFalse(status.isSuccess());
 517         Assert.assertTrue(status.getDescription().contains("Invalid name"));
 518
 519         fc.setName("Config");
 520         status = fc.validate();
 521         Assert.assertFalse(status.isSuccess());
 522         Assert.assertTrue(status.getDescription().contains("Node is null"));
 523
 524         fc.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
 525         Assert.assertFalse(fc.validate().isSuccess());
 526         List<String> actions = new ArrayList<String>();
 527         fc.setActions(actions);
 528         Assert.assertFalse(fc.validate().isSuccess());
 529         actions.add("OUTPUT=2");
 530         fc.setActions(actions);
 531         Assert.assertTrue(fc.validate().isSuccess());
 532
 533         fc.setPriority("-1");
 534         status = fc.validate();
 535         Assert.assertFalse(status.isSuccess());
 536         Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 65535"));
 537
 538         fc.setPriority("100000");
 539         status = fc.validate();
 540         Assert.assertFalse(status.isSuccess());
 541         Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 65535"));
 542
 543         fc.setPriority("2000");
 544         Assert.assertTrue(fc.validate().isSuccess());
 545
 546         fc.setCookie("100");
 547         Assert.assertTrue(fc.validate().isSuccess());
 548
 549         fc.setIngressPort("100");
 550         Assert.assertTrue(fc.validate().isSuccess());
 551
 552         fc.setVlanId(("-1"));
 553         status = fc.validate();
 554         Assert.assertFalse(status.isSuccess());
 555         Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 4095"));
 556
 557         fc.setVlanId("5000");
 558         status = fc.validate();
 559         Assert.assertFalse(status.isSuccess());
 560         Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 4095"));
 561
 562         fc.setVlanId("100");
 563         Assert.assertTrue(fc.validate().isSuccess());
 564
 565         fc.setVlanPriority("-1");
 566         status = fc.validate();
 567         Assert.assertFalse(status.isSuccess());
 568         Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 7"));
 569
 570         fc.setVlanPriority("9");
 571         status = fc.validate();
 572         Assert.assertFalse(status.isSuccess());
 573         Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 7"));
 574
 575         fc.setVlanPriority("5");
 576         Assert.assertTrue(fc.validate().isSuccess());
 577
 578         fc.setEtherType("-1");
 579         status = fc.validate();
 580         Assert.assertFalse(status.isSuccess());
 581         Assert.assertTrue(status.getDescription().contains("Ethernet type"));
 582
 583         fc.setEtherType("0xfffff");
 584         status = fc.validate();
 585         Assert.assertFalse(status.isSuccess());
 586         Assert.assertTrue(status.getDescription().contains("Ethernet type"));
 587
 588         fc.setEtherType("0x800");
 589         Assert.assertTrue(fc.validate().isSuccess());
 590
 591         fc.setTosBits("-1");
 592         status = fc.validate();
 593         Assert.assertFalse(status.isSuccess());
 594         Assert.assertTrue(status.getDescription().contains("IP ToS bits"));
 595
 596         fc.setTosBits("65");
 597         status = fc.validate();
 598         Assert.assertFalse(status.isSuccess());
 599         Assert.assertTrue(status.getDescription().contains("IP ToS bits"));
 600
 601         fc.setTosBits("60");
 602         Assert.assertTrue(fc.validate().isSuccess());
 603
 604         fc.setSrcPort("-1");
 605         status = fc.validate();
 606         Assert.assertFalse(status.isSuccess());
 607         Assert.assertTrue(status.getDescription().contains("Transport source port"));
 608
 609         fc.setSrcPort("0xfffff");
 610         status = fc.validate();
 611         Assert.assertFalse(status.isSuccess());
 612         Assert.assertTrue(status.getDescription().contains("Transport source port"));
 613
 614         fc.setSrcPort("0");
 615         Assert.assertTrue(fc.validate().isSuccess());
 616
 617         fc.setSrcPort("0x00ff");
 618         Assert.assertTrue(fc.validate().isSuccess());
 619
 620         fc.setSrcPort("0xffff");
 621         Assert.assertTrue(fc.validate().isSuccess());
 622
 623         fc.setDstPort("-1");
 624         status = fc.validate();
 625         Assert.assertFalse(status.isSuccess());
 626         Assert.assertTrue(status.getDescription().contains("Transport destination port"));
 627
 628         fc.setDstPort("0xfffff");
 629         status = fc.validate();
 630         Assert.assertFalse(status.isSuccess());
 631         Assert.assertTrue(status.getDescription().contains("Transport destination port"));
 632
 633         fc.setDstPort("0");
 634         Assert.assertTrue(fc.validate().isSuccess());
 635
 636         fc.setDstPort("0x00ff");
 637         Assert.assertTrue(fc.validate().isSuccess());
 638
 639         fc.setDstPort("0xffff");
 640         Assert.assertTrue(fc.validate().isSuccess());
 641
 642         fc.setSrcMac("abc");
 643         status = fc.validate();
 644         Assert.assertFalse(status.isSuccess());
 645         Assert.assertTrue(status.getDescription().contains("Ethernet source address"));
 646
 647         fc.setSrcMac("00:A0:C9:14:C8:29");
 648         Assert.assertTrue(fc.validate().isSuccess());
 649
 650         fc.setDstMac("abc");
 651         status = fc.validate();
 652         Assert.assertFalse(status.isSuccess());
 653         Assert.assertTrue(status.getDescription().contains("Ethernet destination address"));
 654
 655         fc.setDstMac("00:A0:C9:22:AB:11");
 656         Assert.assertTrue(fc.validate().isSuccess());
 657
 658         fc.setSrcIp("-1");
 659         status = fc.validate();
 660         Assert.assertFalse(status.isSuccess());
 661         Assert.assertTrue(status.getDescription().contains("IP source address"));
 662
 663         fc.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
 664         status = fc.validate();
 665         Assert.assertFalse(status.isSuccess());
 666         Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Src IP"));
 667
 668         fc.setEtherType("0x86dd");
 669         Assert.assertTrue(fc.validate().isSuccess());
 670
 671         fc.setSrcIp("1.1.1.1");
 672         status = fc.validate();
 673         Assert.assertFalse(status.isSuccess());
 674         Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Src IP"));
 675
 676         fc.setEtherType("0x800");
 677         Assert.assertTrue(fc.validate().isSuccess());
 678
 679         fc.setDstIp("-1");
 680         status = fc.validate();
 681         Assert.assertFalse(status.isSuccess());
 682         Assert.assertTrue(status.getDescription().contains("IP destination address"));
 683
 684         fc.setDstIp("2001:420:281:1004:407a:57f4:4d15:c355");
 685         status = fc.validate();
 686         Assert.assertFalse(status.isSuccess());
 687         Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Dst IP"));
 688
 689         fc.setEtherType("0x86dd");
 690         fc.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
 691         Assert.assertTrue(fc.validate().isSuccess());
 692
 693         fc.setDstIp("2.2.2.2");
 694         status = fc.validate();
 695         Assert.assertFalse(status.isSuccess());
 696         Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Dst IP"));
 697
 698         fc.setEtherType("0x800");
 699         fc.setSrcIp("1.1.1.1");
 700         Assert.assertTrue(fc.validate().isSuccess());
 701
 702         fc.setEtherType(null);
 703         fc.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
 704         status = fc.validate();
 705         Assert.assertFalse(status.isSuccess());
 706         Assert.assertTrue(status.getDescription().contains("IP Src Dest Type mismatch"));
 707
 708         fc.setSrcIp("1.1.1.1");
 709         fc.setIdleTimeout("-1");
 710         status = fc.validate();
 711         Assert.assertFalse(status.isSuccess());
 712         Assert.assertTrue(status.getDescription().contains("Idle Timeout value"));
 713
 714         fc.setIdleTimeout("0xfffff");
 715         status = fc.validate();
 716         Assert.assertFalse(status.isSuccess());
 717         Assert.assertTrue(status.getDescription().contains("Idle Timeout value"));
 718
 719         fc.setIdleTimeout("10");
 720         Assert.assertTrue(fc.validate().isSuccess());
 721
 722         fc.setHardTimeout("-1");
 723         status = fc.validate();
 724         Assert.assertFalse(status.isSuccess());
 725         Assert.assertTrue(status.getDescription().contains("Hard Timeout value"));
 726
 727         fc.setHardTimeout("0xfffff");
 728         status = fc.validate();
 729         Assert.assertFalse(status.isSuccess());
 730         Assert.assertTrue(status.getDescription().contains("Hard Timeout value"));
 731
 732         fc.setHardTimeout("10");
 733         Assert.assertTrue(fc.validate().isSuccess());
 734
 735     }
 736
 737     private FlowConfig createSampleFlowConfig() throws UnknownHostException {
 738         ArrayList<String> actions;
 739         actions = createSampleActionList();
 740         // actions.add(ActionType.CONTROLLER.toString());
 741         FlowConfig flowConfig = new FlowConfig("true", "Config1", Node.fromString(Node.NodeIDType.OPENFLOW, "1"),
 742                 "100", "0", "60", "2", "100", "0", "0x0800", "00:A0:C9:14:C8:29", "00:A0:C9:22:AB:11",
 743                 IPProtocols.TCP.toString(), "0", "1.2.3.4", "2.2.2.2", "8080", "100", "300", "1000", actions);
 744         return flowConfig;
 745
 746     }
 747
 748     private ArrayList<String> createSampleActionList() {
 749         ArrayList<String> actions = new ArrayList<String>();
 750         actions.add(ActionType.DROP.toString());
 751         actions.add(ActionType.LOOPBACK.toString());
 752         actions.add(ActionType.FLOOD.toString());
 753         actions.add(ActionType.SW_PATH.toString());
 754         actions.add(ActionType.HW_PATH.toString());
 755         actions.add(ActionType.SET_VLAN_PCP.toString() + "=1");
 756         actions.add(ActionType.SET_VLAN_ID.toString() + "=1");
 757         actions.add(ActionType.POP_VLAN.toString());
 758         actions.add(ActionType.SET_DL_SRC.toString() + "=00:A0:C1:AB:22:11");
 759         actions.add(ActionType.SET_DL_DST.toString() + "=00:B1:C1:00:AA:BB");
 760         actions.add(ActionType.SET_NW_SRC.toString() + "=1.1.1.1");
 761         actions.add(ActionType.SET_NW_DST.toString() + "=2.2.2.2");
 762         actions.add(ActionType.CONTROLLER.toString());
 763         actions.add(ActionType.SET_NW_TOS.toString() + "=1");
 764         actions.add(ActionType.SET_TP_SRC.toString() + "=60");
 765         actions.add(ActionType.SET_TP_DST.toString() + "=8080");
 766         actions.add(ActionType.SET_NEXT_HOP.toString() + "=1.1.1.1");
 767
 768         return actions;
 769     }
 770
 771     private Flow getSampleFlowV6(Node node) throws UnknownHostException {
 772         NodeConnector port = NodeConnectorCreator.createOFNodeConnector((short) 24, node);
 773         NodeConnector oport = NodeConnectorCreator.createOFNodeConnector((short) 30, node);
 774         byte srcMac[] = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9a, (byte) 0xbc };
 775         byte dstMac[] = { (byte) 0x1a, (byte) 0x2b, (byte) 0x3c, (byte) 0x4d, (byte) 0x5e, (byte) 0x6f };
 776         byte newMac[] = { (byte) 0x11, (byte) 0xaa, (byte) 0xbb, (byte) 0x34, (byte) 0x9a, (byte) 0xee };
 777         InetAddress srcIP = InetAddress.getByName("2001:420:281:1004:407a:57f4:4d15:c355");
 778         InetAddress dstIP = InetAddress.getByName("2001:420:281:1004:e123:e688:d655:a1b0");
 779         InetAddress ipMask = InetAddress.getByName("ffff:ffff:ffff:ffff:0:0:0:0");
 780         InetAddress ipMask2 = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:0");
 781         InetAddress newIP = InetAddress.getByName("2056:650::a1b0");
 782         short ethertype = EtherTypes.IPv6.shortValue();
 783         short vlan = (short) 27;
 784         byte vlanPr = (byte) 3;
 785         Byte tos = 4;
 786         byte proto = IPProtocols.UDP.byteValue();
 787         short src = (short) 5500;
 788         short dst = 80;
 789
 790         /*
 791          * Create a SAL Flow aFlow
 792          */
 793         Match match = new Match();
 794         match.setField(MatchType.IN_PORT, port);
 795         match.setField(MatchType.DL_SRC, srcMac);
 796         match.setField(MatchType.DL_DST, dstMac);
 797         match.setField(MatchType.DL_TYPE, ethertype);
 798         match.setField(MatchType.DL_VLAN, vlan);
 799         match.setField(MatchType.DL_VLAN_PR, vlanPr);
 800         match.setField(MatchType.NW_SRC, srcIP, ipMask);
 801         match.setField(MatchType.NW_DST, dstIP, ipMask2);
 802         match.setField(MatchType.NW_TOS, tos);
 803         match.setField(MatchType.NW_PROTO, proto);
 804         match.setField(MatchType.TP_SRC, src);
 805         match.setField(MatchType.TP_DST, dst);
 806
 807         List<Action> actions = new ArrayList<Action>();
 808         actions.add(new Controller());
 809         actions.add(new SetVlanId(5));
 810         actions.add(new SetDlDst(newMac));
 811         actions.add(new SetNwDst(newIP));
 812         actions.add(new Output(oport));
 813         actions.add(new PopVlan());
 814         actions.add(new Flood());
 815
 816         Flow flow = new Flow(match, actions);
 817         flow.setPriority((short) 300);
 818         flow.setHardTimeout((short) 240);
 819
 820         return flow;
 821     }
 822 }