| /** |
| * Copyright 2013, Big Switch Networks, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| * not use this file except in compliance with the License. You may obtain |
| * a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations |
| * under the License. |
| **/ |
| |
| package net.floodlightcontroller.core.internal; |
| |
| import static org.easymock.EasyMock.*; |
| import static org.junit.Assert.*; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.ConcurrentHashMap; |
| |
| import net.floodlightcontroller.core.FloodlightContext; |
| import net.floodlightcontroller.core.IFloodlightProviderService; |
| import net.floodlightcontroller.core.IOFSwitch; |
| import net.floodlightcontroller.core.SwitchDriverSubHandshakeAlreadyStarted; |
| import net.floodlightcontroller.core.SwitchDriverSubHandshakeCompleted; |
| import net.floodlightcontroller.core.SwitchDriverSubHandshakeNotStarted; |
| import net.floodlightcontroller.core.IOFSwitch.PortChangeEvent; |
| import net.floodlightcontroller.core.IOFSwitch.PortChangeType; |
| import net.floodlightcontroller.debugcounter.DebugCounter; |
| import net.floodlightcontroller.debugcounter.IDebugCounterService; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.projectfloodlight.openflow.protocol.OFFactories; |
| import org.projectfloodlight.openflow.protocol.OFFactory; |
| import org.projectfloodlight.openflow.protocol.OFMessage; |
| import org.projectfloodlight.openflow.protocol.OFNiciraControllerRole; |
| import org.projectfloodlight.openflow.protocol.OFPortConfig; |
| import org.projectfloodlight.openflow.protocol.OFPortDesc; |
| import org.projectfloodlight.openflow.protocol.OFPortFeatures; |
| import org.projectfloodlight.openflow.protocol.OFPortReason; |
| import org.projectfloodlight.openflow.protocol.OFPortState; |
| import org.projectfloodlight.openflow.protocol.OFPortStatus; |
| import org.projectfloodlight.openflow.protocol.OFVersion; |
| import org.projectfloodlight.openflow.types.DatapathId; |
| import org.projectfloodlight.openflow.types.OFPort; |
| |
| public class OFSwitchImplBaseTest { |
| |
| IFloodlightProviderService floodlightProvider; |
| Map<Long, IOFSwitch> switches; |
| |
| private class OFSwitchTest extends OFSwitchImplBase { |
| public OFSwitchTest(IFloodlightProviderService fp) { |
| super(); |
| stringId = "whatever"; |
| datapathId = DatapathId.of(1L); |
| floodlightProvider = fp; |
| } |
| |
| @Override |
| public void write(OFMessage msg, FloodlightContext cntx) {} |
| |
| |
| @Override |
| public String toString() { |
| return "OFSwitchTest"; |
| } |
| } |
| |
| private OFSwitchTest sw; |
| |
| /* |
| * AAS: Setting the factory to default value of OF1.0 wire protocol. |
| * TODO: revisit this when we do 1.2 unit testing. |
| */ |
| private OFFactory factory10 = OFFactories.getFactory(OFVersion.OF_10); |
| |
| private OFPortDesc p1a; |
| private OFPortDesc p1b; |
| private OFPortDesc p2a; |
| private OFPortDesc p2b; |
| private OFPortDesc p3; |
| private final OFPortDesc portFoo1 = factory10.buildPortDesc() |
| .setName("foo") |
| .setPortNo(OFPort.of(11)) |
| .build(); |
| private final OFPortDesc portFoo2 = factory10.buildPortDesc() |
| .setName("foo") |
| .setPortNo(OFPort.of(12)) |
| .build(); |
| private final OFPortDesc portBar1 = factory10.buildPortDesc() |
| .setName("bar") |
| .setPortNo(OFPort.of(11)) |
| .build(); |
| private final OFPortDesc portBar2 = factory10.buildPortDesc() |
| .setName("bar") |
| .setPortNo(OFPort.of(12)) |
| .build(); |
| private final PortChangeEvent portFoo1Add = |
| new PortChangeEvent(portFoo1, PortChangeType.ADD); |
| private final PortChangeEvent portFoo2Add = |
| new PortChangeEvent(portFoo2, PortChangeType.ADD); |
| private final PortChangeEvent portBar1Add = |
| new PortChangeEvent(portBar1, PortChangeType.ADD); |
| private final PortChangeEvent portBar2Add = |
| new PortChangeEvent(portBar2, PortChangeType.ADD); |
| private final PortChangeEvent portFoo1Del = |
| new PortChangeEvent(portFoo1, PortChangeType.DELETE); |
| private final PortChangeEvent portFoo2Del = |
| new PortChangeEvent(portFoo2, PortChangeType.DELETE); |
| private final PortChangeEvent portBar1Del = |
| new PortChangeEvent(portBar1, PortChangeType.DELETE); |
| private final PortChangeEvent portBar2Del = |
| new PortChangeEvent(portBar2, PortChangeType.DELETE); |
| |
| @Before |
| public void setUp() throws Exception { |
| |
| floodlightProvider = createMock(IFloodlightProviderService.class); |
| sw = new OFSwitchTest(floodlightProvider); |
| IDebugCounterService debugCounter = new DebugCounter(); |
| sw.setDebugCounterService(debugCounter); |
| switches = new ConcurrentHashMap<Long, IOFSwitch>(); |
| switches.put(sw.getId(), sw); |
| expect(floodlightProvider.getSwitch(sw.getId())).andReturn(sw).anyTimes(); |
| |
| } |
| |
| /** |
| * Takes a state and adds it to the passed state set |
| * |
| * @param state the set to add to or remove from |
| * @param aState the state to be added or removed. |
| * @param op add or remove operation |
| * @return |
| */ |
| private <T> Set<T> modState(Set<T> state, T aState, boolean op) { |
| if (state == null) |
| state = new HashSet<T>(); |
| if (op) { |
| state.add(aState); |
| } else { |
| state.remove(aState); |
| } |
| return state; |
| } |
| |
| /** |
| * Check if a port is enabled |
| * @param p the port |
| * @return true id port is enabled and false otherwise. |
| */ |
| private boolean isEnabled(OFPortDesc p) { |
| return (p != null && |
| !p.getState().contains(OFPortState.LINK_DOWN) && |
| !p.getState().contains(OFPortState.BLOCKED) && |
| !p.getConfig().contains(OFPortConfig.PORT_DOWN)); |
| } |
| |
| @Before |
| public void setUpPorts() { |
| /* |
| * Convenience variables to enhance readability. |
| */ |
| final boolean ADD = true; |
| final boolean REM = !ADD; |
| |
| OFPortDesc.Builder bld = factory10.buildPortDesc(); |
| // p1a is disabled |
| |
| p1a = bld.setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .setState(modState(bld.getState(), OFPortState.LINK_DOWN, ADD)) |
| .build(); |
| |
| assertFalse("Sanity check portEnabled", isEnabled(p1a)); |
| |
| bld = factory10.buildPortDesc(); |
| // p1b is enabled |
| // p1b has different feature from p1a |
| p1b = bld.setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .setAdvertised(modState(bld.getAdvertised(), |
| OFPortFeatures.PF_1GB_FD, ADD)) |
| .setState(modState(bld.getState(), |
| OFPortState.LINK_DOWN, REM)) |
| .setConfig(modState(bld.getConfig(), OFPortConfig.PORT_DOWN, REM)) |
| .build(); |
| assertTrue("Sanity check portEnabled", isEnabled(p1b)); |
| |
| // p2 is disabled |
| // p2 has mixed case |
| bld = factory10.buildPortDesc(); |
| p2a = bld.setName("Port2") |
| .setState(modState(bld.getState(), |
| OFPortState.LINK_DOWN, REM)) |
| .setConfig(modState(bld.getConfig(), |
| OFPortConfig.PORT_DOWN, ADD)) |
| .setPortNo(OFPort.of(2)) |
| .build(); |
| |
| // p2b only differs in PortFeatures |
| bld = factory10.buildPortDesc(); |
| |
| p2b = bld.setName("Port2") |
| .setState(modState(bld.getState(), |
| OFPortState.LINK_DOWN, REM)) |
| .setConfig(modState(bld.getConfig(), |
| OFPortConfig.PORT_DOWN, ADD)) |
| .setPortNo(OFPort.of(2)) |
| .setAdvertised(modState(bld.getAdvertised(), |
| OFPortFeatures.PF_100MB_HD, ADD)) |
| .build(); |
| assertFalse("Sanity check portEnabled", isEnabled(p2a)); |
| |
| // p3 is enabled |
| // p3 has mixed case |
| bld = factory10.buildPortDesc(); |
| p3 = bld.setName("porT3") |
| .setState(modState(bld.getState(), |
| OFPortState.LINK_DOWN, REM)) |
| .setPortNo(OFPort.of(3)) |
| .build(); |
| assertTrue("Sanity check portEnabled", isEnabled(p3)); |
| |
| } |
| |
| /** |
| * Test whether two collections contains the same elements, regardless |
| * of the order in which the elements appear in the collections |
| * @param expected |
| * @param actual |
| */ |
| private static <T> void assertCollectionEqualsNoOrder(Collection<T> expected, |
| Collection<T> actual) { |
| String msg = String.format("expected=%s, actual=%s", |
| expected, actual); |
| assertEquals(msg, expected.size(), actual.size()); |
| for(T e: expected) { |
| if (!actual.contains(e)) { |
| msg = String.format("Expected element %s not found in " + |
| "actual. expected=%s, actual=%s", |
| e, expected, actual); |
| fail(msg); |
| } |
| } |
| } |
| |
| |
| /** |
| * Test "normal" setPorts() and comparePorts() methods. No name<->number |
| * conflicts or exception testing. |
| */ |
| @Test |
| public void testBasicSetPortOperations() { |
| Collection<OFPortDesc> oldPorts = Collections.emptyList(); |
| Collection<OFPortDesc> oldEnabledPorts = Collections.emptyList(); |
| Collection<Integer> oldEnabledPortNumbers = Collections.emptyList(); |
| List<OFPortDesc> ports = new ArrayList<OFPortDesc>(); |
| |
| |
| Collection<PortChangeEvent> expectedChanges = |
| new ArrayList<IOFSwitch.PortChangeEvent>(); |
| |
| Collection<PortChangeEvent> actualChanges = sw.comparePorts(ports); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertEquals(0, sw.getPorts().size()); |
| assertEquals(0, sw.getEnabledPorts().size()); |
| assertEquals(0, sw.getEnabledPortNumbers().size()); |
| |
| actualChanges = sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertEquals(0, sw.getPorts().size()); |
| assertEquals(0, sw.getEnabledPorts().size()); |
| assertEquals(0, sw.getEnabledPortNumbers().size()); |
| |
| //--------------------------------------------- |
| // Add port p1a and p2a |
| ports.add(p1a); |
| ports.add(p2a); |
| |
| PortChangeEvent evP1aAdded = |
| new PortChangeEvent(p1a, PortChangeType.ADD); |
| PortChangeEvent evP2aAdded = |
| new PortChangeEvent(p2a, PortChangeType.ADD); |
| |
| expectedChanges.clear(); |
| expectedChanges.add(evP1aAdded); |
| expectedChanges.add(evP2aAdded); |
| |
| actualChanges = sw.comparePorts(ports); |
| assertEquals(0, sw.getPorts().size()); |
| assertEquals(0, sw.getEnabledPorts().size()); |
| assertEquals(0, sw.getEnabledPortNumbers().size()); |
| assertEquals(2, actualChanges.size()); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| |
| actualChanges = sw.setPorts(ports); |
| assertEquals(2, actualChanges.size()); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| assertTrue("enabled ports should be empty", |
| sw.getEnabledPortNumbers().isEmpty()); |
| assertTrue("enabled ports should be empty", |
| sw.getEnabledPorts().isEmpty()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2a, sw.getPort((short)2)); |
| assertEquals(p2a, sw.getPort("port2")); |
| assertEquals(p2a, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)3)); |
| assertEquals(null, sw.getPort("port3")); |
| assertEquals(null, sw.getPort("PoRt3")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // Set the same ports again. No changes |
| oldPorts = sw.getPorts(); |
| oldEnabledPorts = sw.getEnabledPorts(); |
| oldEnabledPortNumbers = sw.getEnabledPortNumbers(); |
| |
| expectedChanges.clear(); |
| |
| actualChanges = sw.comparePorts(ports); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertEquals(oldPorts, sw.getPorts()); |
| assertEquals(oldEnabledPorts, sw.getEnabledPorts()); |
| assertEquals(oldEnabledPortNumbers, sw.getEnabledPortNumbers()); |
| |
| actualChanges = sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertEquals(oldPorts, sw.getPorts()); |
| assertEquals(oldEnabledPorts, sw.getEnabledPorts()); |
| assertEquals(oldEnabledPortNumbers, sw.getEnabledPortNumbers()); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| assertTrue("enabled ports should be empty", |
| sw.getEnabledPortNumbers().isEmpty()); |
| assertTrue("enabled ports should be empty", |
| sw.getEnabledPorts().isEmpty()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2a, sw.getPort((short)2)); |
| assertEquals(p2a, sw.getPort("port2")); |
| assertEquals(p2a, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)3)); |
| assertEquals(null, sw.getPort("port3")); |
| assertEquals(null, sw.getPort("PoRt3")); // case insensitive get |
| |
| //---------------------------------------------------- |
| // Remove p1a, add p1b. Should receive a port up |
| oldPorts = sw.getPorts(); |
| oldEnabledPorts = sw.getEnabledPorts(); |
| oldEnabledPortNumbers = sw.getEnabledPortNumbers(); |
| ports.clear(); |
| ports.add(p2a); |
| ports.add(p1b); |
| |
| // comparePorts |
| PortChangeEvent evP1bUp = new PortChangeEvent(p1b, PortChangeType.UP); |
| actualChanges = sw.comparePorts(ports); |
| assertEquals(oldPorts, sw.getPorts()); |
| assertEquals(oldEnabledPorts, sw.getEnabledPorts()); |
| assertEquals(oldEnabledPortNumbers, sw.getEnabledPortNumbers()); |
| assertEquals(1, actualChanges.size()); |
| assertTrue("No UP event for port1", actualChanges.contains(evP1bUp)); |
| |
| // setPorts |
| actualChanges = sw.setPorts(ports); |
| assertEquals(1, actualChanges.size()); |
| assertTrue("No UP event for port1", actualChanges.contains(evP1bUp)); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| List<OFPortDesc> enabledPorts = new ArrayList<OFPortDesc>(); |
| enabledPorts.add(p1b); |
| List<Integer> enabledPortNumbers = new ArrayList<Integer>(); |
| enabledPortNumbers.add(1); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1b, sw.getPort((short)1)); |
| assertEquals(p1b, sw.getPort("port1")); |
| assertEquals(p1b, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2a, sw.getPort((short)2)); |
| assertEquals(p2a, sw.getPort("port2")); |
| assertEquals(p2a, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)3)); |
| assertEquals(null, sw.getPort("port3")); |
| assertEquals(null, sw.getPort("PoRt3")); // case insensitive get |
| |
| //---------------------------------------------------- |
| // Remove p2a, add p2b. Should receive a port modify |
| oldPorts = sw.getPorts(); |
| oldEnabledPorts = sw.getEnabledPorts(); |
| oldEnabledPortNumbers = sw.getEnabledPortNumbers(); |
| ports.clear(); |
| ports.add(p2b); |
| ports.add(p1b); |
| |
| PortChangeEvent evP2bModified = |
| new PortChangeEvent(p2b, PortChangeType.OTHER_UPDATE); |
| |
| // comparePorts |
| actualChanges = sw.comparePorts(ports); |
| assertEquals(oldPorts, sw.getPorts()); |
| assertEquals(oldEnabledPorts, sw.getEnabledPorts()); |
| assertEquals(oldEnabledPortNumbers, sw.getEnabledPortNumbers()); |
| assertEquals(1, actualChanges.size()); |
| assertTrue("No OTHER_CHANGE event for port2", |
| actualChanges.contains(evP2bModified)); |
| |
| // setPorts |
| actualChanges = sw.setPorts(ports); |
| assertEquals(1, actualChanges.size()); |
| assertTrue("No OTHER_CHANGE event for port2", |
| actualChanges.contains(evP2bModified)); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts = new ArrayList<OFPortDesc>(); |
| enabledPorts.add(p1b); |
| enabledPortNumbers = new ArrayList<Integer>(); |
| enabledPortNumbers.add(1); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1b, sw.getPort((short)1)); |
| assertEquals(p1b, sw.getPort("port1")); |
| assertEquals(p1b, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2b, sw.getPort((short)2)); |
| assertEquals(p2b, sw.getPort("port2")); |
| assertEquals(p2b, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)3)); |
| assertEquals(null, sw.getPort("port3")); |
| assertEquals(null, sw.getPort("PoRt3")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // Remove p1b, add p1a. Should receive a port DOWN |
| // Remove p2b, add p2a. Should receive a port modify |
| // Add p3, should receive an add |
| oldPorts = sw.getPorts(); |
| oldEnabledPorts = sw.getEnabledPorts(); |
| oldEnabledPortNumbers = sw.getEnabledPortNumbers(); |
| ports.clear(); |
| ports.add(p2a); |
| ports.add(p1a); |
| ports.add(p3); |
| |
| PortChangeEvent evP1aDown = |
| new PortChangeEvent(p1a, PortChangeType.DOWN); |
| PortChangeEvent evP2aModified = |
| new PortChangeEvent(p2a, PortChangeType.OTHER_UPDATE); |
| PortChangeEvent evP3Add = |
| new PortChangeEvent(p3, PortChangeType.ADD); |
| expectedChanges.clear(); |
| expectedChanges.add(evP1aDown); |
| expectedChanges.add(evP2aModified); |
| expectedChanges.add(evP3Add); |
| |
| // comparePorts |
| actualChanges = sw.comparePorts(ports); |
| assertEquals(oldPorts, sw.getPorts()); |
| assertEquals(oldEnabledPorts, sw.getEnabledPorts()); |
| assertEquals(oldEnabledPortNumbers, sw.getEnabledPortNumbers()); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| |
| // setPorts |
| actualChanges = sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPorts.add(p3); |
| enabledPortNumbers.clear(); |
| enabledPortNumbers.add(3); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2a, sw.getPort((short)2)); |
| assertEquals(p2a, sw.getPort("port2")); |
| assertEquals(p2a, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(p3, sw.getPort((short)3)); |
| assertEquals(p3, sw.getPort("port3")); |
| assertEquals(p3, sw.getPort("PoRt3")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // Remove p1b Should receive a port DELETE |
| // Remove p2b Should receive a port DELETE |
| oldPorts = sw.getPorts(); |
| oldEnabledPorts = sw.getEnabledPorts(); |
| oldEnabledPortNumbers = sw.getEnabledPortNumbers(); |
| ports.clear(); |
| ports.add(p3); |
| |
| PortChangeEvent evP1aDel = |
| new PortChangeEvent(p1a, PortChangeType.DELETE); |
| PortChangeEvent evP2aDel = |
| new PortChangeEvent(p2a, PortChangeType.DELETE); |
| expectedChanges.clear(); |
| expectedChanges.add(evP1aDel); |
| expectedChanges.add(evP2aDel); |
| |
| // comparePorts |
| actualChanges = sw.comparePorts(ports); |
| assertEquals(oldPorts, sw.getPorts()); |
| assertEquals(oldEnabledPorts, sw.getEnabledPorts()); |
| assertEquals(oldEnabledPortNumbers, sw.getEnabledPortNumbers()); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| |
| // setPorts |
| actualChanges = sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPorts.add(p3); |
| enabledPortNumbers.clear(); |
| enabledPortNumbers.add(3); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| |
| assertEquals(p3, sw.getPort((short)3)); |
| assertEquals(p3, sw.getPort("port3")); |
| assertEquals(p3, sw.getPort("PoRt3")); // case insensitive get |
| } |
| |
| |
| /** |
| * Test "normal" OFPortStatus handling. No name<->number |
| * conflicts or exception testing. |
| */ |
| @Test |
| public void testBasicPortStatusOperation() { |
| OFPortStatus ps = null; |
| List<OFPortDesc> ports = new ArrayList<OFPortDesc>(); |
| ports.add(p1a); |
| ports.add(p2a); |
| |
| |
| // Set p1a and p2a as baseline |
| PortChangeEvent evP1aAdded = |
| new PortChangeEvent(p1a, PortChangeType.ADD); |
| PortChangeEvent evP2aAdded = |
| new PortChangeEvent(p2a, PortChangeType.ADD); |
| |
| Collection<PortChangeEvent> expectedChanges = |
| new ArrayList<IOFSwitch.PortChangeEvent>(); |
| expectedChanges.add(evP1aAdded); |
| expectedChanges.add(evP2aAdded); |
| |
| Collection<PortChangeEvent> actualChanges = sw.comparePorts(ports); |
| assertEquals(0, sw.getPorts().size()); |
| assertEquals(0, sw.getEnabledPorts().size()); |
| assertEquals(0, sw.getEnabledPortNumbers().size()); |
| assertEquals(2, actualChanges.size()); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| |
| actualChanges = sw.setPorts(ports); |
| assertEquals(2, actualChanges.size()); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| assertTrue("enabled ports should be empty", |
| sw.getEnabledPortNumbers().isEmpty()); |
| assertTrue("enabled ports should be empty", |
| sw.getEnabledPorts().isEmpty()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2a, sw.getPort((short)2)); |
| assertEquals(p2a, sw.getPort("port2")); |
| assertEquals(p2a, sw.getPort("PoRt2")); // case insensitive get |
| |
| //---------------------------------------------------- |
| // P1a -> p1b. Should receive a port up |
| ports.clear(); |
| ports.add(p2a); |
| ports.add(p1b); |
| |
| ps = factory10.buildPortStatus().setReason(OFPortReason.MODIFY).setDesc(p1b).build(); |
| |
| PortChangeEvent evP1bUp = new PortChangeEvent(p1b, PortChangeType.UP); |
| actualChanges = sw.processOFPortStatus(ps); |
| expectedChanges.clear(); |
| expectedChanges.add(evP1bUp); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| List<OFPortDesc> enabledPorts = new ArrayList<OFPortDesc>(); |
| enabledPorts.add(p1b); |
| List<Integer> enabledPortNumbers = new ArrayList<Integer>(); |
| enabledPortNumbers.add(1); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1b, sw.getPort((short)1)); |
| assertEquals(p1b, sw.getPort("port1")); |
| assertEquals(p1b, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2a, sw.getPort((short)2)); |
| assertEquals(p2a, sw.getPort("port2")); |
| assertEquals(p2a, sw.getPort("PoRt2")); // case insensitive get |
| |
| //---------------------------------------------------- |
| // p2a -> p2b. Should receive a port modify |
| ports.clear(); |
| ports.add(p2b); |
| ports.add(p1b); |
| |
| PortChangeEvent evP2bModified = |
| new PortChangeEvent(p2b, PortChangeType.OTHER_UPDATE); |
| |
| ps = ps.createBuilder().setReason(OFPortReason.MODIFY).setDesc(p2b).build(); |
| |
| |
| |
| actualChanges = sw.processOFPortStatus(ps); |
| expectedChanges.clear(); |
| expectedChanges.add(evP2bModified); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts = new ArrayList<OFPortDesc>(); |
| enabledPorts.add(p1b); |
| enabledPortNumbers = new ArrayList<Integer>(); |
| enabledPortNumbers.add(1); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1b, sw.getPort((short)1)); |
| assertEquals(p1b, sw.getPort("port1")); |
| assertEquals(p1b, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2b, sw.getPort((short)2)); |
| assertEquals(p2b, sw.getPort("port2")); |
| assertEquals(p2b, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)3)); |
| assertEquals(null, sw.getPort("port3")); |
| assertEquals(null, sw.getPort("PoRt3")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // p1b -> p1a. Via an OFPPR_ADD, Should receive a port DOWN |
| ports.clear(); |
| ports.add(p2b); |
| ports.add(p1a); |
| |
| // we use an ADD here. We treat ADD and MODIFY the same way |
| ps = ps.createBuilder().setReason(OFPortReason.ADD).setDesc(p1a).build(); |
| |
| |
| PortChangeEvent evP1aDown = |
| new PortChangeEvent(p1a, PortChangeType.DOWN); |
| actualChanges = sw.processOFPortStatus(ps); |
| expectedChanges.clear(); |
| expectedChanges.add(evP1aDown); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPortNumbers.clear(); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2b, sw.getPort((short)2)); |
| assertEquals(p2b, sw.getPort("port2")); |
| assertEquals(p2b, sw.getPort("PoRt2")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // p2b -> p2a. Via an OFPPR_ADD, Should receive a port MODIFY |
| ports.clear(); |
| ports.add(p2a); |
| ports.add(p1a); |
| |
| // we use an ADD here. We treat ADD and MODIFY the same way |
| ps = ps.createBuilder().setReason(OFPortReason.ADD).setDesc(p2a).build(); |
| |
| PortChangeEvent evP2aModify = |
| new PortChangeEvent(p2a, PortChangeType.OTHER_UPDATE); |
| actualChanges = sw.processOFPortStatus(ps); |
| expectedChanges.clear(); |
| expectedChanges.add(evP2aModify); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPortNumbers.clear(); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(p2a, sw.getPort((short)2)); |
| assertEquals(p2a, sw.getPort("port2")); |
| assertEquals(p2a, sw.getPort("PoRt2")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // Remove p2a |
| ports.clear(); |
| ports.add(p1a); |
| |
| ps = ps.createBuilder().setReason(OFPortReason.DELETE).setDesc(p2a).build(); |
| |
| PortChangeEvent evP2aDel = |
| new PortChangeEvent(p2a, PortChangeType.DELETE); |
| actualChanges = sw.processOFPortStatus(ps); |
| expectedChanges.clear(); |
| expectedChanges.add(evP2aDel); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPortNumbers.clear(); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)2)); |
| assertEquals(null, sw.getPort("port2")); |
| assertEquals(null, sw.getPort("PoRt2")); // case insensitive get |
| |
| //---------------------------------------------------- |
| // Remove p2a again. Nothing should happen. |
| ports.clear(); |
| ports.add(p1a); |
| |
| ps = ps.createBuilder().setReason(OFPortReason.DELETE).setDesc(p2a).build(); |
| |
| actualChanges = sw.processOFPortStatus(ps); |
| expectedChanges.clear(); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPortNumbers.clear(); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1a, sw.getPort((short)1)); |
| assertEquals(p1a, sw.getPort("port1")); |
| assertEquals(p1a, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)2)); |
| assertEquals(null, sw.getPort("port2")); |
| assertEquals(null, sw.getPort("PoRt2")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // Remove p1a |
| ports.clear(); |
| |
| ps = ps.createBuilder().setReason(OFPortReason.DELETE).setDesc(p1a).build(); |
| |
| PortChangeEvent evP1aDel = |
| new PortChangeEvent(p1a, PortChangeType.DELETE); |
| actualChanges = sw.processOFPortStatus(ps); |
| expectedChanges.clear(); |
| expectedChanges.add(evP1aDel); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPortNumbers.clear(); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(null, sw.getPort((short)1)); |
| assertEquals(null, sw.getPort("port1")); |
| assertEquals(null, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)2)); |
| assertEquals(null, sw.getPort("port2")); |
| assertEquals(null, sw.getPort("PoRt2")); // case insensitive get |
| |
| |
| //---------------------------------------------------- |
| // Add p3, should receive an add |
| ports.clear(); |
| ports.add(p3); |
| |
| PortChangeEvent evP3Add = |
| new PortChangeEvent(p3, PortChangeType.ADD); |
| expectedChanges.clear(); |
| expectedChanges.add(evP3Add); |
| |
| ps = ps.createBuilder().setReason(OFPortReason.ADD).setDesc(p3).build(); |
| |
| actualChanges = sw.processOFPortStatus(ps); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPorts.add(p3); |
| enabledPortNumbers.clear(); |
| enabledPortNumbers.add(3); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(null, sw.getPort((short)1)); |
| assertEquals(null, sw.getPort("port1")); |
| assertEquals(null, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)2)); |
| assertEquals(null, sw.getPort("port2")); |
| assertEquals(null, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(p3, sw.getPort((short)3)); |
| assertEquals(p3, sw.getPort("port3")); |
| assertEquals(p3, sw.getPort("PoRt3")); // case insensitive get |
| |
| //---------------------------------------------------- |
| // Add p1b, back should receive an add |
| ports.clear(); |
| ports.add(p1b); |
| ports.add(p3); |
| |
| PortChangeEvent evP1bAdd = |
| new PortChangeEvent(p1b, PortChangeType.ADD); |
| expectedChanges.clear(); |
| expectedChanges.add(evP1bAdd); |
| |
| // use a modify to add the port |
| ps = ps.createBuilder().setReason(OFPortReason.MODIFY).setDesc(p1b).build(); |
| |
| actualChanges = sw.processOFPortStatus(ps); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPorts.add(p3); |
| enabledPorts.add(p1b); |
| enabledPortNumbers.clear(); |
| enabledPortNumbers.add(3); |
| enabledPortNumbers.add(1); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1b, sw.getPort((short)1)); |
| assertEquals(p1b, sw.getPort("port1")); |
| assertEquals(p1b, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)2)); |
| assertEquals(null, sw.getPort("port2")); |
| assertEquals(null, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(p3, sw.getPort((short)3)); |
| assertEquals(p3, sw.getPort("port3")); |
| assertEquals(p3, sw.getPort("PoRt3")); // case insensitive get |
| |
| //---------------------------------------------------- |
| // Modify, but nothing really changed |
| ports.clear(); |
| ports.add(p1b); |
| ports.add(p3); |
| |
| expectedChanges.clear(); |
| |
| // use a modify to add the port |
| ps = ps.createBuilder().setReason(OFPortReason.MODIFY).setDesc(p1b).build(); |
| |
| actualChanges = sw.processOFPortStatus(ps); |
| assertCollectionEqualsNoOrder(expectedChanges, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| enabledPorts.clear(); |
| enabledPorts.add(p3); |
| enabledPorts.add(p1b); |
| enabledPortNumbers.clear(); |
| enabledPortNumbers.add(3); |
| enabledPortNumbers.add(1); |
| assertCollectionEqualsNoOrder(enabledPorts, sw.getEnabledPorts()); |
| assertCollectionEqualsNoOrder(enabledPortNumbers, |
| sw.getEnabledPortNumbers()); |
| assertEquals(p1b, sw.getPort((short)1)); |
| assertEquals(p1b, sw.getPort("port1")); |
| assertEquals(p1b, sw.getPort("PoRt1")); // case insensitive get |
| |
| assertEquals(null, sw.getPort((short)2)); |
| assertEquals(null, sw.getPort("port2")); |
| assertEquals(null, sw.getPort("PoRt2")); // case insensitive get |
| |
| assertEquals(p3, sw.getPort((short)3)); |
| assertEquals(p3, sw.getPort("port3")); |
| assertEquals(p3, sw.getPort("PoRt3")); // case insensitive get |
| } |
| |
| |
| /** |
| * Test exception handling for setPorts() and comparePorts() |
| */ |
| @Test |
| @SuppressWarnings("EmptyStatement") |
| public void testSetPortExceptions() { |
| try { |
| sw.setPorts(null); |
| fail("Expected exception not thrown"); |
| } catch (NullPointerException e) { }; |
| |
| // two ports with same name |
| List<OFPortDesc> ports = new ArrayList<OFPortDesc>(); |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(2)) |
| .build()); |
| |
| try { |
| sw.setPorts(ports); |
| fail("Expected exception not thrown"); |
| } catch (IllegalArgumentException e) { }; |
| |
| // two ports with same number |
| ports.clear(); |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| ports.add(factory10.buildPortDesc().setName("port2") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| |
| try { |
| sw.setPorts(ports); |
| fail("Expected exception not thrown"); |
| } catch (IllegalArgumentException e) { }; |
| |
| // null port in list |
| ports.clear(); |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| |
| ports.add(null); |
| try { |
| sw.setPorts(ports); |
| fail("Excpeted exception not thrown"); |
| } catch (NullPointerException e) { }; |
| |
| // try getPort(null) |
| try { |
| sw.getPort(null); |
| fail("Excpeted exception not thrown"); |
| } catch (NullPointerException e) { }; |
| |
| //-------------------------- |
| // comparePorts() |
| try { |
| sw.comparePorts(null); |
| fail("Excpeted exception not thrown"); |
| } catch (NullPointerException e) { }; |
| |
| // two ports with same name |
| ports = new ArrayList<OFPortDesc>(); |
| |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(2)) |
| .build()); |
| |
| try { |
| sw.comparePorts(ports); |
| fail("Excpeted exception not thrown"); |
| } catch (IllegalArgumentException e) { }; |
| |
| // two ports with same number |
| ports.clear(); |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| ports.add(factory10.buildPortDesc().setName("port2") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| |
| try { |
| sw.comparePorts(ports); |
| fail("Excpeted exception not thrown"); |
| } catch (IllegalArgumentException e) { }; |
| |
| // null port in list |
| ports.clear(); |
| ports.add(factory10.buildPortDesc().setName("port1") |
| .setPortNo(OFPort.of(1)) |
| .build()); |
| ports.add(null); |
| try { |
| sw.comparePorts(ports); |
| fail("Excpeted exception not thrown"); |
| } catch (NullPointerException e) { }; |
| |
| // try getPort(null) |
| try { |
| sw.getPort(null); |
| fail("Excpeted exception not thrown"); |
| } catch (NullPointerException e) { }; |
| |
| } |
| |
| @Test |
| public void testPortStatusExceptions() { |
| |
| try { |
| sw.processOFPortStatus(null); |
| fail("Expected exception not thrown"); |
| } catch (NullPointerException e) { } |
| |
| // illegal reason code |
| |
| /* |
| * |
| * AAS: Can't do this test because LOXI doesn't give you the ability to |
| * set your own reason as a byte. |
| * |
| * ps = ps.createBuilder().setReason(OFPortReason.).build(); |
| * ps.setDesc(OFPortDesc.create("p1", (short)1).toOFPhysicalPort()); |
| * try { |
| * sw.processOFPortStatus(ps); |
| * fail("Expected exception not thrown"); |
| * } catch (IllegalArgumentException e) { } |
| */ |
| |
| /* |
| * AAS: Loxi does not allow you to define a PortStatus message |
| * with no port so skipping this test. |
| * |
| * // null port |
| * ps = factory10.buildPortStatus().setReason(OFPortReason.ADD) |
| * .setDesc(null) |
| * .build(); |
| * |
| * try { |
| * sw.processOFPortStatus(ps); |
| * fail("Expected exception not thrown"); |
| * } catch (NullPointerException e) { } |
| */ |
| } |
| |
| /** |
| * Assert that the expected PortChangeEvents have been recevied, asserting |
| * the expected ordering. |
| * |
| * All events in earlyEvents have to appear in actualEvents before any |
| * event in lateEvent appears. Events in anytimeEvents can appear at any |
| * given time. earlyEvents, lateEvents, and anytimeEvents must be mutually |
| * exclusive (their intersection must be none) and their union must |
| * contain all elements from actualEvents |
| * @param earlyEvents |
| * @param lateEvents |
| * @param anytimeEvents |
| * @param actualEvents |
| */ |
| private static void assertChangeEvents(Collection<PortChangeEvent> earlyEvents, |
| Collection<PortChangeEvent> lateEvents, |
| Collection<PortChangeEvent> anytimeEvents, |
| Collection<PortChangeEvent> actualEvents) { |
| String inputDesc = String.format("earlyEvents=%s, lateEvents=%s, " + |
| "anytimeEvents=%s, actualEvents=%s", |
| earlyEvents, lateEvents, anytimeEvents, actualEvents); |
| // Make copies of expected lists, so we can modify them |
| Collection<PortChangeEvent> early = |
| new ArrayList<PortChangeEvent>(earlyEvents); |
| Collection<PortChangeEvent> late = |
| new ArrayList<PortChangeEvent>(lateEvents); |
| Collection<PortChangeEvent> any = |
| new ArrayList<PortChangeEvent>(anytimeEvents); |
| |
| // Sanity check: no overlap between early, late, and anytime events |
| for (PortChangeEvent ev: early) { |
| assertFalse("Test setup error. Early and late overlap", |
| late.contains(ev)); |
| assertFalse("Test setup error. Early and anytime overlap", |
| any.contains(ev)); |
| } |
| for (PortChangeEvent ev: late) { |
| assertFalse("Test setup error. Late and early overlap", |
| early.contains(ev)); |
| assertFalse("Test setup error. Late and any overlap", |
| any.contains(ev)); |
| } |
| for (PortChangeEvent ev: any) { |
| assertFalse("Test setup error. Anytime and early overlap", |
| early.contains(ev)); |
| assertFalse("Test setup error. Anytime and late overlap", |
| late.contains(ev)); |
| } |
| |
| for (PortChangeEvent a: actualEvents) { |
| if (early.remove(a)) { |
| continue; |
| } |
| if (any.remove(a)) { |
| continue; |
| } |
| if (late.remove(a)) { |
| if (!early.isEmpty()) { |
| fail(a + " is in late list, but haven't seen all required " + |
| "early events. " + inputDesc); |
| } else { |
| continue; |
| } |
| } |
| fail(a + " was not expected. " + inputDesc); |
| } |
| if (!early.isEmpty()) |
| fail("Elements left in early: " + early + ". " + inputDesc); |
| if (!late.isEmpty()) |
| fail("Elements left in late: " + late + ". " + inputDesc); |
| if (!any.isEmpty()) |
| fail("Elements left in any: " + any + ". " + inputDesc); |
| } |
| |
| /** |
| * Test setPort() with changing name / number mappings |
| * We don't test comparePorts() here. We assume setPorts() and |
| * comparePorts() use the same underlying implementation |
| */ |
| @Test |
| public void testSetPortNameNumberMappingChange() { |
| |
| List<OFPortDesc> ports = new ArrayList<OFPortDesc>(); |
| Collection<PortChangeEvent> early = new ArrayList<PortChangeEvent>(); |
| Collection<PortChangeEvent> late = new ArrayList<PortChangeEvent>(); |
| Collection<PortChangeEvent> anytime = new ArrayList<PortChangeEvent>(); |
| Collection<PortChangeEvent> actualChanges = null; |
| |
| ports.add(portFoo1); |
| ports.add(p1a); |
| sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Add portFoo2: name collision |
| ports.clear(); |
| ports.add(portFoo2); |
| ports.add(p1a); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.setPorts(ports); |
| early.add(portFoo1Del); |
| late.add(portFoo2Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Add portBar2: number collision |
| ports.clear(); |
| ports.add(portBar2); |
| ports.add(p1a); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.setPorts(ports); |
| early.add(portFoo2Del); |
| late.add(portBar2Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Set to portFoo1, portBar2. No collisions in this step |
| ports.clear(); |
| ports.add(portFoo1); |
| ports.add(portBar2); |
| ports.add(p1a); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.setPorts(ports); |
| anytime.add(portFoo1Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Add portFoo2: name and number collision |
| ports.clear(); |
| ports.add(portFoo2); |
| ports.add(p1a); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.setPorts(ports); |
| early.add(portFoo1Del); |
| early.add(portBar2Del); |
| late.add(portFoo2Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Set to portFoo2, portBar1. No collisions in this step |
| ports.clear(); |
| ports.add(portFoo2); |
| ports.add(portBar1); |
| ports.add(p1a); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.setPorts(ports); |
| anytime.add(portBar1Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Add portFoo1, portBar2 name and number collision |
| // Also change p1a -> p1b: expect modify for it |
| // Also add p3: expect add for it |
| PortChangeEvent p1bUp = new PortChangeEvent(p1b, PortChangeType.UP); |
| PortChangeEvent p3Add = new PortChangeEvent(p3, PortChangeType.ADD); |
| ports.clear(); |
| ports.add(portFoo1); |
| ports.add(portBar2); |
| ports.add(p1b); |
| ports.add(p3); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.setPorts(ports); |
| early.add(portFoo2Del); |
| early.add(portBar1Del); |
| late.add(portFoo1Add); |
| late.add(portBar2Add); |
| anytime.add(p1bUp); |
| anytime.add(p3Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| } |
| |
| |
| @Test |
| public void testPortStatusNameNumberMappingChange() { |
| List<OFPortDesc> ports = new ArrayList<OFPortDesc>(); |
| Collection<PortChangeEvent> early = new ArrayList<PortChangeEvent>(); |
| Collection<PortChangeEvent> late = new ArrayList<PortChangeEvent>(); |
| Collection<PortChangeEvent> anytime = new ArrayList<PortChangeEvent>(); |
| Collection<PortChangeEvent> actualChanges = null; |
| |
| // init: add portFoo1, p1a |
| ports.add(portFoo1); |
| ports.add(p1a); |
| sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| OFPortStatus ps = factory10.buildPortStatus() |
| .setReason(OFPortReason.MODIFY) |
| .setDesc(portFoo2) |
| .build(); |
| |
| // portFoo1 -> portFoo2 via MODIFY : name collision |
| ports.clear(); |
| ports.add(portFoo2); |
| ports.add(p1a); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.processOFPortStatus(ps); |
| early.add(portFoo1Del); |
| late.add(portFoo2Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // portFoo2 -> portBar2 via ADD number collision |
| ps = ps.createBuilder().setReason(OFPortReason.ADD) |
| .setDesc(portBar2) |
| .build(); |
| |
| ports.clear(); |
| ports.add(portBar2); |
| ports.add(p1a); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.processOFPortStatus(ps); |
| early.add(portFoo2Del); |
| late.add(portBar2Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Set to portFoo1, portBar2 |
| ports.clear(); |
| ports.add(portFoo1); |
| ports.add(portBar2); |
| sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // portFoo1 + portBar2 -> portFoo2: name and number collision |
| ps = ps.createBuilder().setReason(OFPortReason.MODIFY) |
| .setDesc(portFoo2) |
| .build(); |
| |
| ports.clear(); |
| ports.add(portFoo2); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.processOFPortStatus(ps); |
| early.add(portFoo1Del); |
| early.add(portBar2Del); |
| late.add(portFoo2Add); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| //---------------------- |
| // Test DELETEs |
| |
| // del portFoo1: name exists (portFoo2), but number doesn't. |
| ps = ps.createBuilder().setReason(OFPortReason.DELETE) |
| .setDesc(portFoo1) |
| .build(); |
| |
| ports.clear(); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.processOFPortStatus(ps); |
| anytime.add(portFoo2Del); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // Set to portFoo1 |
| ports.clear(); |
| ports.add(portFoo1); |
| sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // del portBar1: number exists (portFoo1), but name doesn't. |
| ps = ps.createBuilder().setReason(OFPortReason.DELETE) |
| .setDesc(portBar1) |
| .build(); |
| |
| ports.clear(); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.processOFPortStatus(ps); |
| anytime.add(portFoo1Del); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| |
| // Set to portFoo1, portBar2 |
| ports.clear(); |
| ports.add(portFoo1); |
| ports.add(portBar2); |
| sw.setPorts(ports); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| |
| // del portFoo2: name and number exists |
| ps = ps.createBuilder().setReason(OFPortReason.DELETE) |
| .setDesc(portFoo2) |
| .build(); |
| |
| ports.clear(); |
| early.clear(); |
| late.clear(); |
| anytime.clear(); |
| actualChanges = sw.processOFPortStatus(ps); |
| anytime.add(portFoo1Del); |
| anytime.add(portBar2Del); |
| assertChangeEvents(early, late, anytime, actualChanges); |
| assertCollectionEqualsNoOrder(ports, sw.getPorts()); |
| } |
| |
| @Test |
| public void testSubHandshake() { |
| //Nicira role messages are vendor extentions should do the job. |
| OFMessage m = factory10.niciraControllerRoleRequest(OFNiciraControllerRole.ROLE_MASTER); |
| // BasicFactory.getInstance().getMessage(OFType.VENDOR); |
| // test execptions before handshake is started |
| try { |
| sw.processDriverHandshakeMessage(m); |
| fail("expected exception not thrown"); |
| } catch (SwitchDriverSubHandshakeNotStarted e) { /* expected */ } |
| try { |
| sw.isDriverHandshakeComplete(); |
| fail("expected exception not thrown"); |
| } catch (SwitchDriverSubHandshakeNotStarted e) { /* expected */ } |
| |
| // start the handshake -- it should immediately complete |
| try { |
| sw.startDriverHandshake(); |
| } catch (IOException e1) { |
| fail("Unexpected IOException thrown."); |
| } |
| assertTrue("Handshake should be complete", |
| sw.isDriverHandshakeComplete()); |
| |
| // test exceptions after handshake is completed |
| try { |
| sw.processDriverHandshakeMessage(m); |
| fail("expected exception not thrown"); |
| } catch (SwitchDriverSubHandshakeCompleted e) { /* expected */ } |
| try { |
| sw.startDriverHandshake(); |
| fail("Expected exception not thrown"); |
| } catch (SwitchDriverSubHandshakeAlreadyStarted e) { |
| /* expected */ |
| } catch (IOException e) { |
| fail("Unexpected IOException thrown."); |
| } |
| } |
| |
| } |