2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.controller.forwardingrulesmanager;
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;
17 import java.util.concurrent.ConcurrentHashMap;
18 import java.util.concurrent.ConcurrentMap;
20 import org.junit.Assert;
21 import org.junit.Test;
22 import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
23 import org.opendaylight.controller.forwardingrulesmanager.FlowEntry;
24 import org.opendaylight.controller.sal.action.Action;
25 import org.opendaylight.controller.sal.action.ActionType;
26 import org.opendaylight.controller.sal.action.Controller;
27 import org.opendaylight.controller.sal.action.Flood;
28 import org.opendaylight.controller.sal.action.Output;
29 import org.opendaylight.controller.sal.action.PopVlan;
30 import org.opendaylight.controller.sal.action.SetDlDst;
31 import org.opendaylight.controller.sal.action.SetNwDst;
32 import org.opendaylight.controller.sal.action.SetVlanId;
33 import org.opendaylight.controller.sal.core.ContainerFlow;
34 import org.opendaylight.controller.sal.core.Node;
35 import org.opendaylight.controller.sal.core.NodeConnector;
36 import org.opendaylight.controller.sal.flowprogrammer.Flow;
37 import org.opendaylight.controller.sal.match.Match;
38 import org.opendaylight.controller.sal.match.MatchType;
39 import org.opendaylight.controller.sal.utils.EtherTypes;
40 import org.opendaylight.controller.sal.utils.IPProtocols;
41 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
42 import org.opendaylight.controller.sal.utils.NodeCreator;
43 import org.opendaylight.controller.sal.utils.Status;
45 public class frmTest {
48 public void testFlowEntryInstall() throws UnknownHostException {
49 Node node = NodeCreator.createOFNode(1L);
50 FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
51 FlowEntry pol2 = new FlowEntry("polTest2", null, getSampleFlowV6(node), node);
52 FlowEntryInstall fei = new FlowEntryInstall(pol.clone(), null);
53 FlowEntryInstall fei2 = new FlowEntryInstall(pol.clone(), null);
54 FlowEntryInstall fei3 = new FlowEntryInstall(pol2.clone(), null);
55 Assert.assertTrue(fei.getOriginal().equals(pol));
56 Assert.assertTrue(fei.getInstall().equals(pol));
57 Assert.assertTrue(fei.getFlowName().equals(pol.getFlowName()));
58 Assert.assertTrue(fei.getGroupName().equals(pol.getGroupName()));
59 Assert.assertTrue(fei.getNode().equals(pol.getNode()));
60 Assert.assertFalse(fei.isDeletePending());
62 Assert.assertTrue(fei.isDeletePending());
63 Assert.assertNull(fei.getContainerFlow());
64 Assert.assertTrue(fei.equalsByNodeAndName(pol.getNode(), pol.getFlowName()));
66 Assert.assertTrue(fei.equals(fei2));
67 Assert.assertFalse(fei.equals(null));
68 Assert.assertTrue(fei.equals(fei3));
73 public void testFlowEntryCreation() throws UnknownHostException {
74 Node node = NodeCreator.createOFNode(1L);
75 FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
76 Assert.assertTrue(pol.getFlow().equals(getSampleFlowV6(node)));
80 public void testFlowEntrySetGet() throws UnknownHostException {
81 Node node = NodeCreator.createOFNode(1L);
82 Node node2 = NodeCreator.createOFNode(2L);
83 FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
84 pol.setGroupName("polTest2");
85 pol.setFlowName("flowName");
86 Assert.assertTrue(pol.getFlowName().equals("flowName"));
87 Assert.assertTrue(pol.getGroupName().equals("polTest2"));
89 Assert.assertTrue(pol.getNode().equals(node2));
90 Assert.assertTrue(pol.equalsByNodeAndName(node2, "flowName"));
94 public void testFlowEntryEquality() throws UnknownHostException {
95 Node node = NodeCreator.createOFNode(1L);
96 Node node2 = NodeCreator.createOFNode(1L);
97 FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
98 FlowEntry pol2 = new FlowEntry("polTest", null, getSampleFlowV6(node), node2);
99 Assert.assertTrue(pol.equals(pol2));
103 public void testFlowEntryCollision() throws UnknownHostException {
104 // Create 2 equal FlowEntry objects
105 Node node1 = NodeCreator.createOFNode(1L);
106 Node node2 = NodeCreator.createOFNode(1L);
107 FlowEntry fe1 = new FlowEntry("Junit", "flow1", getSampleFlowV6(node1), node1);
108 FlowEntry fe2 = new FlowEntry("Junit", "flow2", getSampleFlowV6(node2), node1);
110 // Check equality in FlowEntry and parameters
111 Assert.assertTrue(fe1.getFlow().getMatch().equals(fe2.getFlow().getMatch()));
112 Assert.assertTrue(fe1.getFlow().getMatch().getMatches() == fe2.getFlow().getMatch().getMatches());
113 Assert.assertTrue(fe1.getFlow().getMatch().hashCode() == fe2.getFlow().getMatch().hashCode());
114 Assert.assertTrue(fe1.getFlow().hashCode() == fe2.getFlow().hashCode());
115 Assert.assertTrue(fe1.equals(fe2));
116 Assert.assertTrue(fe1.hashCode() == fe2.hashCode());
118 // Change priority field for fe2, verify inequality
119 fe2.getFlow().setPriority((short)1000);
121 // Verify FlowEntry works as key in collection
122 ConcurrentMap<FlowEntry, FlowEntry> map = new ConcurrentHashMap<FlowEntry, FlowEntry>();
123 Assert.assertTrue(null == map.put(fe1, fe1));
124 Assert.assertTrue(fe1.clone().equals(map.put(fe1.clone(), fe1.clone())));
125 Assert.assertTrue(map.get(fe1.clone()).equals(fe1.clone()));
126 Assert.assertTrue(map.keySet().contains(fe1.clone()));
127 Assert.assertTrue(map.containsKey(fe1));
131 Assert.assertTrue(map.isEmpty());
132 Assert.assertFalse(map.containsKey(fe1));
134 // Verify cloned object as key
135 map.put(fe1.clone(), fe1.clone());
136 Assert.assertTrue(map.containsKey(fe1));
138 // Verify different key is not present
139 Assert.assertFalse(map.containsKey(fe2));
142 map.put(fe2.clone(), fe2.clone());
143 Assert.assertTrue(map.size() == 2);
144 Assert.assertTrue(map.containsKey(fe1));
145 Assert.assertTrue(map.containsKey(fe2));
147 // Make fe2 equal to fe1 again
148 fe2.getFlow().setPriority((short)300);
149 Assert.assertTrue(fe2.equals(fe1));
150 Assert.assertTrue(map.containsKey(fe2));
157 public void testFlowEntryInstallCollision() throws UnknownHostException {
158 // Create 2 equal FlowEntryInstall objects
159 Node node1 = NodeCreator.createOFNode(1L);
160 Node node2 = NodeCreator.createOFNode(1L);
161 FlowEntry fe1 = new FlowEntry("Junit", "flow1", getSampleFlowV6(node1), node1);
162 FlowEntry fe2 = new FlowEntry("Junit", "flow2", getSampleFlowV6(node2), node1);
163 ContainerFlow cf1 = null;
164 ContainerFlow cf2 = null;
165 FlowEntryInstall fei1 = new FlowEntryInstall(fe1, cf1);
166 FlowEntryInstall fei2 = new FlowEntryInstall(fe2, cf2);
168 // Check equality in FlowEntry and parameters
169 Assert.assertTrue(fei1.equals(fei2));
170 Assert.assertTrue(fei1.hashCode() == fei2.hashCode());
172 // Verify FlowEntryInstall works as key in collection
173 ConcurrentMap<FlowEntryInstall, FlowEntryInstall> map =
174 new ConcurrentHashMap<FlowEntryInstall, FlowEntryInstall>();
175 Assert.assertTrue(null == map.put(fei1, fei1));
176 Assert.assertTrue(map.get(fei1).equals(fei2));
177 Assert.assertTrue(map.keySet().contains(fei1));
178 Assert.assertTrue(map.keySet().contains(fei2));
179 Assert.assertTrue(map.containsKey(fei1));
183 Assert.assertTrue(map.isEmpty());
184 Assert.assertFalse(map.containsKey(fei1));
186 // Verify cloned object as key
188 Assert.assertTrue(map.containsKey(fei1));
190 // Change fei2, change relevant hashcode info
191 fei2.getInstall().getFlow().setPriority((short)301);
192 Assert.assertFalse(fei1.equals(fei2));
193 Assert.assertFalse(fei1.hashCode() == fei2.hashCode());
196 // Verify different key is not present
197 Assert.assertFalse(map.containsKey(fei2));
201 Assert.assertTrue(map.size() == 2);
202 Assert.assertTrue(map.containsKey(fei1));
203 Assert.assertTrue(map.containsKey(fei2));
205 // Make fei2 equal to fei1 again
206 fei2.getInstall().getFlow().setPriority((short)300);
207 Assert.assertTrue(fei2.equals(fei1));
208 Assert.assertTrue(map.containsKey(fei2));
215 public void testFlowEntryCloning() throws UnknownHostException {
216 Node node = NodeCreator.createOFNode(1L);
217 FlowEntry pol = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
218 FlowEntry pol2 = pol.clone();
219 Assert.assertTrue(pol.equals(pol2));
223 public void testFlowEntrySet() throws UnknownHostException {
224 Set<FlowEntry> set = new HashSet<FlowEntry>();
226 Node node1 = NodeCreator.createOFNode(1L);
227 Node node2 = NodeCreator.createOFNode(2L);
228 Node node3 = NodeCreator.createOFNode(3L);
230 Match match = new Match();
231 match.setField(MatchType.NW_SRC, InetAddress.getAllByName("1.1.1.1"));
232 match.setField(MatchType.NW_DST, InetAddress.getAllByName("2.2.2.2"));
233 match.setField(MatchType.DL_TYPE, EtherTypes.IPv4.shortValue());
235 List<Action> actionList = new ArrayList<Action>();
236 // actionList.add(new Drop());
238 Flow flow = new Flow(match, actionList);
239 FlowEntry pol1 = new FlowEntry("m1", "same", flow, node1);
240 FlowEntry pol2 = new FlowEntry("m2", "same", flow, node2);
241 FlowEntry pol3 = new FlowEntry("m3", "same", flow, node3);
247 Assert.assertTrue(set.contains(pol1));
248 Assert.assertTrue(set.contains(pol2));
249 Assert.assertTrue(set.contains(pol3));
251 Assert.assertTrue(set.contains(pol1.clone()));
252 Assert.assertTrue(set.contains(pol2.clone()));
253 Assert.assertTrue(set.contains(pol3.clone()));
258 public void testInternalFlow() {
259 FlowConfig flowConfig = new FlowConfig();
260 Assert.assertFalse(flowConfig.isInternalFlow());
261 flowConfig.setName("__Internal__");
262 Status status = flowConfig.validate(null);
263 Assert.assertFalse(status.isSuccess());
264 Assert.assertTrue(status.getDescription().contains("name"));
265 Assert.assertTrue(flowConfig.isInternalFlow());
266 flowConfig.setName("External");
267 Assert.assertFalse(flowConfig.isInternalFlow());
271 public void testFlowConfigCreateSet() throws UnknownHostException {
272 FlowConfig frmC = new FlowConfig();
273 FlowConfig frmC3 = new FlowConfig();
274 Node node = NodeCreator.createOFNode(1L);
275 FlowEntry entry = new FlowEntry("polTest", null, getSampleFlowV6(node), node);
277 // testing equal function
278 Assert.assertFalse(frmC.equals(null));
279 Assert.assertTrue(frmC.equals(frmC));
280 Assert.assertTrue(frmC.equals(frmC3));
281 Assert.assertFalse(frmC.equals(entry));
282 FlowConfig flowC = createSampleFlowConfig();
283 Assert.assertFalse(frmC.equals(flowC));
284 // testing installInHW
285 Assert.assertTrue(frmC.installInHw());
286 frmC.setInstallInHw(false);
287 Assert.assertFalse(frmC.installInHw());
288 frmC.setInstallInHw(true);
289 Assert.assertTrue(frmC.installInHw());
291 // testing general set and get methods
292 ArrayList<String> actions = createSampleActionList();
293 frmC.setActions(actions);
294 Assert.assertFalse(frmC.equals(frmC3));
295 frmC3.setActions(actions);
297 Assert.assertFalse(frmC.equals(flowC));
299 Assert.assertTrue(frmC.getCookie().equals("0"));
300 Assert.assertFalse(frmC.equals(frmC3));
301 frmC3.setCookie("0");
303 Assert.assertFalse(frmC.equals(flowC));
304 frmC.setDstMac("00:A0:C9:22:AB:11");
305 Assert.assertTrue(frmC.getDstMac().equals("00:A0:C9:22:AB:11"));
306 Assert.assertFalse(frmC.equals(frmC3));
307 frmC3.setDstMac("00:A0:C9:22:AB:11");
309 Assert.assertFalse(frmC.equals(flowC));
310 frmC.setSrcMac("00:A0:C9:14:C8:29");
311 Assert.assertTrue(frmC.getSrcMac().equals("00:A0:C9:14:C8:29"));
312 Assert.assertFalse(frmC.equals(frmC3));
313 frmC3.setSrcMac("00:A0:C9:14:C8:29");
315 Assert.assertFalse(frmC.equals(flowC));
316 frmC.setDynamic(true);
317 Assert.assertTrue(frmC.isDynamic());
318 Assert.assertFalse(frmC.equals(frmC3));
319 frmC3.setDynamic(true);
320 flowC.setDynamic(true);
322 Assert.assertFalse(frmC.equals(flowC));
323 frmC.setEtherType("0x0800");
324 Assert.assertTrue(frmC.getEtherType().equals("0x0800"));
325 Assert.assertFalse(frmC.equals(frmC3));
326 frmC3.setEtherType("0x0800");
328 Assert.assertFalse(frmC.equals(flowC));
329 frmC.setIngressPort("60");
330 Assert.assertTrue(frmC.getIngressPort().equals("60"));
331 Assert.assertFalse(frmC.equals(frmC3));
332 frmC3.setIngressPort("60");
334 Assert.assertFalse(frmC.equals(flowC));
335 frmC.setName("Config1");
336 Assert.assertTrue(frmC.getName().equals("Config1"));
337 Assert.assertFalse(frmC.equals(frmC3));
338 frmC3.setName("Config1");
340 Assert.assertFalse(frmC.equals(flowC));
341 frmC.setDstIp("2.2.2.2");
342 Assert.assertTrue(frmC.getDstIp().equals("2.2.2.2"));
343 Assert.assertFalse(frmC.equals(frmC3));
344 frmC3.setDstIp("2.2.2.2");
346 Assert.assertFalse(frmC.equals(flowC));
347 frmC.setSrcIp("1.2.3.4");
348 Assert.assertTrue(frmC.getSrcIp().equals("1.2.3.4"));
349 Assert.assertFalse(frmC.equals(frmC3));
350 frmC3.setSrcIp("1.2.3.4");
352 Assert.assertFalse(frmC.equals(flowC));
353 Assert.assertFalse(frmC.isPortGroupEnabled());
354 frmC.setPortGroup("2");
355 Assert.assertTrue(frmC.isPortGroupEnabled());
356 Assert.assertTrue(frmC.getPortGroup().equals("2"));
357 Assert.assertFalse(frmC.equals(frmC3));
358 frmC3.setPortGroup("2");
360 Assert.assertFalse(frmC.equals(flowC));
361 frmC.setPriority("100");
362 Assert.assertTrue(frmC.getPriority().equals("100"));
363 Assert.assertFalse(frmC.equals(frmC3));
364 frmC3.setPriority("100");
366 Assert.assertFalse(frmC.equals(flowC));
367 frmC.setProtocol(IPProtocols.TCP.toString());
368 Assert.assertTrue(frmC.getProtocol().equals(IPProtocols.TCP.toString()));
369 Assert.assertFalse(frmC.equals(frmC3));
370 frmC3.setProtocol(IPProtocols.TCP.toString());
372 Assert.assertFalse(frmC.equals(flowC));
373 frmC.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
374 Assert.assertTrue(frmC.getNode().equals(Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
375 Assert.assertFalse(frmC.equals(frmC3));
376 frmC3.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
378 Assert.assertFalse(frmC.equals(flowC));
379 frmC.setTosBits("0");
380 Assert.assertTrue(frmC.getTosBits().equals("0"));
381 Assert.assertFalse(frmC.equals(frmC3));
382 frmC3.setTosBits("0");
384 Assert.assertFalse(frmC.equals(flowC));
385 frmC.setDstPort("100");
386 Assert.assertTrue(frmC.getDstPort().equals("100"));
387 Assert.assertFalse(frmC.equals(frmC3));
388 frmC3.setDstPort("100");
390 Assert.assertFalse(frmC.equals(flowC));
391 frmC.setSrcPort("8080");
392 Assert.assertTrue(frmC.getSrcPort().equals("8080"));
393 Assert.assertFalse(frmC.equals(frmC3));
394 frmC3.setSrcPort("8080");
396 Assert.assertFalse(frmC.equals(flowC));
397 frmC.setVlanId("100");
398 Assert.assertTrue(frmC.getVlanId().equals("100"));
399 Assert.assertFalse(frmC.equals(frmC3));
400 frmC3.setVlanId("100");
402 Assert.assertFalse(frmC.equals(flowC));
403 frmC.setVlanPriority("0");
404 Assert.assertTrue(frmC.getVlanPriority().equals("0"));
405 Assert.assertFalse(frmC.equals(frmC3));
406 frmC3.setVlanPriority("0");
408 Assert.assertFalse(frmC.equals(flowC));
409 frmC.setIdleTimeout("300");
410 Assert.assertTrue(frmC.getIdleTimeout().equals("300"));
411 Assert.assertFalse(frmC.equals(frmC3));
412 frmC3.setIdleTimeout("300");
414 Assert.assertFalse(frmC.equals(flowC));
415 frmC.setHardTimeout("1000");
416 Assert.assertTrue(frmC.getHardTimeout().equals("1000"));
417 Assert.assertFalse(frmC.equals(frmC3));
418 frmC3.setHardTimeout("1000");
420 // Assert.assertFalse(frmC.equals(flowC));
421 Assert.assertTrue(actions.equals(frmC.getActions()));
423 FlowConfig frmC2 = new FlowConfig(frmC);
425 Assert.assertFalse(frmC2.equals(frmC));
426 frmC2.setDynamic(false);
427 Assert.assertFalse(frmC2.equals(frmC));
428 frmC2.setDynamic(true);
429 Assert.assertTrue(frmC2.equals(frmC));
430 // Assert.assertFalse(frmC2.equals(frmC3));
431 flowC.setDynamic(true);
432 Assert.assertTrue(flowC.equals(frmC));
433 Assert.assertTrue(flowC.isStatusSuccessful());
434 flowC.setStatus("Invalid");
435 Assert.assertFalse(flowC.isStatusSuccessful());
437 flowC.getActions().add(ActionType.DROP.toString());
438 Assert.assertFalse(flowC.equals(frmC));
439 Assert.assertFalse(flowC.isIPv6());
440 flowC.setDstIp("2001:420:281:1004:407a:57f4:4d15:c355");
441 Assert.assertTrue(flowC.isIPv6());
442 flowC.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
443 Assert.assertTrue(flowC.isIPv6());
445 Long id = (Long) flowC.getNode().getID();
446 Assert.assertTrue(id.toString().equals("1"));
451 public void testFlowConfigEqualities() throws UnknownHostException {
452 FlowConfig fc = new FlowConfig();
453 FlowConfig fc2 = new FlowConfig();
455 fc.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
456 Assert.assertFalse(fc.onNode(Node.fromString(Node.NodeIDType.OPENFLOW, "0")));
457 Assert.assertTrue(fc.onNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
459 Assert.assertTrue(fc.isByNameAndNodeIdEqual("flow1", Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
460 Assert.assertFalse(fc.isByNameAndNodeIdEqual("flow1", Node.fromString(Node.NodeIDType.OPENFLOW, "0")));
461 Assert.assertFalse(fc.isByNameAndNodeIdEqual("flow2", Node.fromString(Node.NodeIDType.OPENFLOW, "1")));
463 Assert.assertFalse(fc.isByNameAndNodeIdEqual(fc2));
464 fc2.setName("flow1");
465 Assert.assertFalse(fc.isByNameAndNodeIdEqual(fc2));
466 fc2.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "0"));
467 Assert.assertFalse(fc.isByNameAndNodeIdEqual(fc2));
468 fc2.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
469 Assert.assertTrue(fc.isByNameAndNodeIdEqual(fc2));
473 public void testStatusToggle() throws UnknownHostException {
474 FlowConfig fc = new FlowConfig();
475 fc.toggleInstallation();
476 Assert.assertTrue(fc.installInHw());
477 fc.toggleInstallation();
478 Assert.assertFalse(fc.installInHw());
479 fc.toggleInstallation();
480 Assert.assertTrue(fc.installInHw());
485 public void testGetFlowEntry() throws UnknownHostException {
486 FlowConfig fc2 = createSampleFlowConfig();
487 FlowEntry fe = fc2.getFlowEntry();
488 Assert.assertNotNull(fe);
492 public void testGetFlow() throws UnknownHostException {
493 FlowConfig fc = new FlowConfig();
494 fc.setActions(createSampleActionList());
495 Flow flow = fc.getFlow();
496 Assert.assertNotNull(flow);
500 public void testL2AddressValid() {
501 FlowConfig fc = new FlowConfig();
502 Assert.assertFalse(fc.isL2AddressValid(null));
503 Assert.assertFalse(fc.isL2AddressValid("11"));
504 Assert.assertFalse(fc.isL2AddressValid("00:A0:C9:14:C8:"));
505 Assert.assertFalse(fc.isL2AddressValid("000:A01:C9:14:C8:211"));
507 Assert.assertTrue(fc.isL2AddressValid("00:A0:C9:14:C8:29"));
511 public void testValid() throws UnknownHostException {
512 FlowConfig fc2 = createSampleFlowConfig();
513 Assert.assertTrue(fc2.validate(null).isSuccess());
515 FlowConfig fc = new FlowConfig();
516 Status status = fc.validate(null);
517 Assert.assertFalse(status.isSuccess());
518 Assert.assertTrue(status.getDescription().contains("Invalid name"));
520 fc.setName("Config");
521 status = fc.validate(null);
522 Assert.assertFalse(status.isSuccess());
523 Assert.assertTrue(status.getDescription().contains("Node is null"));
525 fc.setNode(Node.fromString(Node.NodeIDType.OPENFLOW, "1"));
526 Assert.assertTrue(fc.validate(null).isSuccess());
528 fc.setPriority("-1");
529 status = fc.validate(null);
530 Assert.assertFalse(status.isSuccess());
531 Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 65535"));
533 fc.setPriority("100000");
534 status = fc.validate(null);
535 Assert.assertFalse(status.isSuccess());
536 Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 65535"));
538 fc.setPriority("2000");
539 Assert.assertTrue(fc.validate(null).isSuccess());
542 Assert.assertTrue(fc.validate(null).isSuccess());
544 fc.setIngressPort("-1");
545 status = fc.validate(null);
546 Assert.assertFalse(status.isSuccess());
547 Assert.assertTrue(status.getDescription().contains("is not valid for the Switch"));
549 fc.setIngressPort("100");
550 Assert.assertTrue(fc.validate(null).isSuccess());
552 fc.setVlanId(("-1"));
553 status = fc.validate(null);
554 Assert.assertFalse(status.isSuccess());
555 Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 4095"));
557 fc.setVlanId("5000");
558 status = fc.validate(null);
559 Assert.assertFalse(status.isSuccess());
560 Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 4095"));
563 Assert.assertTrue(fc.validate(null).isSuccess());
565 fc.setVlanPriority("-1");
566 status = fc.validate(null);
567 Assert.assertFalse(status.isSuccess());
568 Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 7"));
570 fc.setVlanPriority("9");
571 status = fc.validate(null);
572 Assert.assertFalse(status.isSuccess());
573 Assert.assertTrue(status.getDescription().contains("is not in the range 0 - 7"));
575 fc.setVlanPriority("5");
576 Assert.assertTrue(fc.validate(null).isSuccess());
578 fc.setEtherType("-1");
579 status = fc.validate(null);
580 Assert.assertFalse(status.isSuccess());
581 Assert.assertTrue(status.getDescription().contains("Ethernet type"));
583 fc.setEtherType("0xfffff");
584 status = fc.validate(null);
585 Assert.assertFalse(status.isSuccess());
586 Assert.assertTrue(status.getDescription().contains("Ethernet type"));
588 fc.setEtherType("0x800");
589 Assert.assertTrue(fc.validate(null).isSuccess());
592 status = fc.validate(null);
593 Assert.assertFalse(status.isSuccess());
594 Assert.assertTrue(status.getDescription().contains("IP ToS bits"));
597 status = fc.validate(null);
598 Assert.assertFalse(status.isSuccess());
599 Assert.assertTrue(status.getDescription().contains("IP ToS bits"));
602 Assert.assertTrue(fc.validate(null).isSuccess());
605 status = fc.validate(null);
606 Assert.assertFalse(status.isSuccess());
607 Assert.assertTrue(status.getDescription().contains("Transport source port"));
609 fc.setSrcPort("0xfffff");
610 status = fc.validate(null);
611 Assert.assertFalse(status.isSuccess());
612 Assert.assertTrue(status.getDescription().contains("Transport source port"));
615 Assert.assertTrue(fc.validate(null).isSuccess());
617 fc.setSrcPort("0x00ff");
618 Assert.assertTrue(fc.validate(null).isSuccess());
620 fc.setSrcPort("0xffff");
621 Assert.assertTrue(fc.validate(null).isSuccess());
624 status = fc.validate(null);
625 Assert.assertFalse(status.isSuccess());
626 Assert.assertTrue(status.getDescription().contains("Transport destination port"));
628 fc.setDstPort("0xfffff");
629 status = fc.validate(null);
630 Assert.assertFalse(status.isSuccess());
631 Assert.assertTrue(status.getDescription().contains("Transport destination port"));
634 Assert.assertTrue(fc.validate(null).isSuccess());
636 fc.setDstPort("0x00ff");
637 Assert.assertTrue(fc.validate(null).isSuccess());
639 fc.setDstPort("0xffff");
640 Assert.assertTrue(fc.validate(null).isSuccess());
643 status = fc.validate(null);
644 Assert.assertFalse(status.isSuccess());
645 Assert.assertTrue(status.getDescription().contains("Ethernet source address"));
647 fc.setSrcMac("00:A0:C9:14:C8:29");
648 Assert.assertTrue(fc.validate(null).isSuccess());
651 status = fc.validate(null);
652 Assert.assertFalse(status.isSuccess());
653 Assert.assertTrue(status.getDescription().contains("Ethernet destination address"));
655 fc.setDstMac("00:A0:C9:22:AB:11");
656 Assert.assertTrue(fc.validate(null).isSuccess());
659 status = fc.validate(null);
660 Assert.assertFalse(status.isSuccess());
661 Assert.assertTrue(status.getDescription().contains("IP source address"));
663 fc.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
664 status = fc.validate(null);
665 Assert.assertFalse(status.isSuccess());
666 Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Src IP"));
668 fc.setEtherType("0x86dd");
669 Assert.assertTrue(fc.validate(null).isSuccess());
671 fc.setSrcIp("1.1.1.1");
672 status = fc.validate(null);
673 Assert.assertFalse(status.isSuccess());
674 Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Src IP"));
676 fc.setEtherType("0x800");
677 Assert.assertTrue(fc.validate(null).isSuccess());
680 status = fc.validate(null);
681 Assert.assertFalse(status.isSuccess());
682 Assert.assertTrue(status.getDescription().contains("IP destination address"));
684 fc.setDstIp("2001:420:281:1004:407a:57f4:4d15:c355");
685 status = fc.validate(null);
686 Assert.assertFalse(status.isSuccess());
687 Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Dst IP"));
689 fc.setEtherType("0x86dd");
690 fc.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
691 Assert.assertTrue(fc.validate(null).isSuccess());
693 fc.setDstIp("2.2.2.2");
694 status = fc.validate(null);
695 Assert.assertFalse(status.isSuccess());
696 Assert.assertTrue(status.getDescription().contains("Type mismatch between Ethernet & Dst IP"));
698 fc.setEtherType("0x800");
699 fc.setSrcIp("1.1.1.1");
700 Assert.assertTrue(fc.validate(null).isSuccess());
702 fc.setEtherType(null);
703 fc.setSrcIp("2001:420:281:1004:407a:57f4:4d15:c355");
704 status = fc.validate(null);
705 Assert.assertFalse(status.isSuccess());
706 Assert.assertTrue(status.getDescription().contains("IP Src Dest Type mismatch"));
708 fc.setSrcIp("1.1.1.1");
709 fc.setIdleTimeout("-1");
710 status = fc.validate(null);
711 Assert.assertFalse(status.isSuccess());
712 Assert.assertTrue(status.getDescription().contains("Idle Timeout value"));
714 fc.setIdleTimeout("0xfffff");
715 status = fc.validate(null);
716 Assert.assertFalse(status.isSuccess());
717 Assert.assertTrue(status.getDescription().contains("Idle Timeout value"));
719 fc.setIdleTimeout("10");
720 Assert.assertTrue(fc.validate(null).isSuccess());
722 fc.setHardTimeout("-1");
723 status = fc.validate(null);
724 Assert.assertFalse(status.isSuccess());
725 Assert.assertTrue(status.getDescription().contains("Hard Timeout value"));
727 fc.setHardTimeout("0xfffff");
728 status = fc.validate(null);
729 Assert.assertFalse(status.isSuccess());
730 Assert.assertTrue(status.getDescription().contains("Hard Timeout value"));
732 fc.setHardTimeout("10");
733 Assert.assertTrue(fc.validate(null).isSuccess());
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);
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");
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;
786 byte proto = IPProtocols.UDP.byteValue();
787 short src = (short) 5500;
791 * Create a SAL Flow aFlow
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);
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());
816 Flow flow = new Flow(match, actions);
817 flow.setPriority((short) 300);
818 flow.setHardTimeout((short) 240);