diff --git a/src/test/java/net/floodlightcontroller/core/internal/OFSwitchImplTest.java b/src/test/java/net/floodlightcontroller/core/internal/OFSwitchImplTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..758cd0563588e7fa759c99ccaec95d2217fe3f21
--- /dev/null
+++ b/src/test/java/net/floodlightcontroller/core/internal/OFSwitchImplTest.java
@@ -0,0 +1,236 @@
+package net.floodlightcontroller.core.internal;
+
+import static org.easymock.EasyMock.*;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+
+import net.floodlightcontroller.core.IFloodlightProviderService.Role;
+import net.floodlightcontroller.core.IOFSwitch;
+import net.floodlightcontroller.core.internal.OFSwitchImpl.PendingRoleRequestEntry;
+import net.floodlightcontroller.core.test.MockFloodlightProvider;
+import net.floodlightcontroller.test.FloodlightTestCase;
+
+import org.easymock.Capture;
+import org.jboss.netty.channel.Channel;
+import org.junit.Before;
+import org.junit.Test;
+import org.openflow.protocol.OFMessage;
+import org.openflow.protocol.OFType;
+import org.openflow.protocol.OFVendor;
+import org.openflow.protocol.vendor.OFVendorData;
+import org.openflow.vendor.nicira.OFNiciraVendorData;
+import org.openflow.vendor.nicira.OFRoleRequestVendorData;
+import org.openflow.vendor.nicira.OFRoleVendorData;
+
+public class OFSwitchImplTest extends FloodlightTestCase {
+ protected OFSwitchImpl sw;
+
+
+ @Before
+ public void setUp() throws Exception {
+ sw = new OFSwitchImpl();
+ Channel ch = createMock(Channel.class);
+ SocketAddress sa = new InetSocketAddress(42);
+ expect(ch.getRemoteAddress()).andReturn(sa).anyTimes();
+ sw.setChannel(ch);
+ MockFloodlightProvider floodlightProvider = new MockFloodlightProvider();
+ sw.setFloodlightProvider(floodlightProvider);
+ }
+
+
+ public void doSendNxRoleRequest(Role role, int nx_role) throws Exception {
+ long cookie = System.nanoTime();
+
+ // verify that the correct OFMessage is sent
+ Capture<List<OFMessage>> msgCapture = new Capture<List<OFMessage>>();
+ expect(sw.channel.write(capture(msgCapture))).andReturn(null);
+ replay(sw.channel);
+ int xid = sw.sendNxRoleRequest(role, cookie);
+ verify(sw.channel);
+ List<OFMessage> msgList = msgCapture.getValue();
+ assertEquals(1, msgList.size());
+ OFMessage msg = msgList.get(0);
+ assertEquals("Transaction Ids must match", xid, msg.getXid());
+ assertTrue("Message must be an OFVendor type", msg instanceof OFVendor);
+ assertEquals(OFType.VENDOR, msg.getType());
+ OFVendor vendorMsg = (OFVendor)msg;
+ assertEquals("Vendor message must be vendor Nicira",
+ OFNiciraVendorData.NX_VENDOR_ID, vendorMsg.getVendor());
+ OFVendorData vendorData = vendorMsg.getVendorData();
+ assertTrue("Vendor Data must be an OFRoleRequestVendorData",
+ vendorData instanceof OFRoleRequestVendorData);
+ OFRoleRequestVendorData roleRequest = (OFRoleRequestVendorData)vendorData;
+ assertEquals(nx_role, roleRequest.getRole());
+
+ // Now verify that we've added the pending request correctly
+ // to the pending queue
+ assertEquals(1, sw.pendingRoleRequests.size());
+ PendingRoleRequestEntry pendingRoleRequest = sw.pendingRoleRequests.poll();
+ assertEquals(msg.getXid(), pendingRoleRequest.xid);
+ assertEquals(role, pendingRoleRequest.role);
+ assertEquals(cookie, pendingRoleRequest.cookie);
+ reset(sw.channel);
+ }
+
+ @Test
+ public void testSendNxRoleRequest() throws Exception {
+ doSendNxRoleRequest(Role.MASTER, OFRoleVendorData.NX_ROLE_MASTER);
+ doSendNxRoleRequest(Role.SLAVE, OFRoleVendorData.NX_ROLE_SLAVE);
+ doSendNxRoleRequest(Role.EQUAL, OFRoleVendorData.NX_ROLE_OTHER);
+ }
+
+
+ @Test
+ public void testDeliverRoleReplyOk() {
+ // test normal case
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ (int)System.currentTimeMillis(), // arbitrary xid
+ Role.MASTER,
+ System.nanoTime() // arbitrary cookie
+ );
+ sw.pendingRoleRequests.add(pending);
+ replay(sw.channel);
+ sw.deliverRoleReply(pending.xid, pending.role);
+ verify(sw.channel);
+ assertEquals(true, sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE));
+ assertEquals(pending.role, sw.role);
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+
+ @Test
+ public void testDeliverRoleReplyOkRepeated() {
+ // test normal case. Not the first role reply
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ (int)System.currentTimeMillis(), // arbitrary xid
+ Role.MASTER,
+ System.nanoTime() // arbitrary cookie
+ );
+ sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, true);
+ sw.pendingRoleRequests.add(pending);
+ replay(sw.channel);
+ sw.deliverRoleReply(pending.xid, pending.role);
+ verify(sw.channel);
+ assertEquals(true, sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE));
+ assertEquals(pending.role, sw.role);
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+
+ @Test
+ public void testDeliverRoleReplyNonePending() {
+ // nothing pending
+ expect(sw.channel.close()).andReturn(null);
+ replay(sw.channel);
+ sw.deliverRoleReply(1, Role.MASTER);
+ verify(sw.channel);
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+
+ @Test
+ public void testDeliverRoleReplyWrongXid() {
+ // wrong xid received
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ (int)System.currentTimeMillis(), // arbitrary xid
+ Role.MASTER,
+ System.nanoTime() // arbitrary cookie
+ );
+ sw.pendingRoleRequests.add(pending);
+ expect(sw.channel.close()).andReturn(null);
+ replay(sw.channel);
+ sw.deliverRoleReply(pending.xid+1, pending.role);
+ verify(sw.channel);
+ assertEquals(null, sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE));
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+
+ @Test
+ public void testDeliverRoleReplyWrongRole() {
+ // correct xid but incorrect role received
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ (int)System.currentTimeMillis(), // arbitrary xid
+ Role.MASTER,
+ System.nanoTime() // arbitrary cookie
+ );
+ sw.pendingRoleRequests.add(pending);
+ expect(sw.channel.close()).andReturn(null);
+ replay(sw.channel);
+ sw.deliverRoleReply(pending.xid, Role.SLAVE);
+ verify(sw.channel);
+ assertEquals(null, sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE));
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+
+ @Test
+ public void testCheckFirstPendingRoleRequestXid() {
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ 54321, Role.MASTER, 232323);
+ replay(sw.channel); // we don't expect any invocations
+ sw.pendingRoleRequests.add(pending);
+ assertEquals(true, sw.checkFirstPendingRoleRequestXid(54321));
+ assertEquals(false, sw.checkFirstPendingRoleRequestXid(0));
+ sw.pendingRoleRequests.clear();
+ assertEquals(false, sw.checkFirstPendingRoleRequestXid(54321));
+ verify(sw.channel);
+ }
+
+ @Test
+ public void testCheckFirstPendingRoleRequestCookie() {
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ 54321, Role.MASTER, 232323);
+ replay(sw.channel); // we don't expect any invocations
+ sw.pendingRoleRequests.add(pending);
+ assertEquals(true, sw.checkFirstPendingRoleRequestCookie(232323));
+ assertEquals(false, sw.checkFirstPendingRoleRequestCookie(0));
+ sw.pendingRoleRequests.clear();
+ assertEquals(false, sw.checkFirstPendingRoleRequestCookie(232323));
+ verify(sw.channel);
+ }
+
+ @Test
+ public void testDeliverRoleRequestNotSupported () {
+ // normal case. xid is pending
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ (int)System.currentTimeMillis(), // arbitrary xid
+ Role.MASTER,
+ System.nanoTime() // arbitrary cookie
+ );
+ sw.role = Role.SLAVE;
+ sw.pendingRoleRequests.add(pending);
+ replay(sw.channel);
+ sw.deliverRoleRequestNotSupported(pending.xid);
+ verify(sw.channel);
+ assertEquals(false, sw.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE));
+ assertEquals(null, sw.role);
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+
+ @Test
+ public void testDeliverRoleRequestNotSupportedNonePending() {
+ // nothing pending
+ sw.role = Role.SLAVE;
+ expect(sw.channel.close()).andReturn(null);
+ replay(sw.channel);
+ sw.deliverRoleRequestNotSupported(1);
+ verify(sw.channel);
+ assertEquals(null, sw.role);
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+
+ @Test
+ public void testDeliverRoleRequestNotSupportedWrongXid() {
+ // wrong xid received
+ PendingRoleRequestEntry pending = new PendingRoleRequestEntry(
+ (int)System.currentTimeMillis(), // arbitrary xid
+ Role.MASTER,
+ System.nanoTime() // arbitrary cookie
+ );
+ sw.role = Role.SLAVE;
+ sw.pendingRoleRequests.add(pending);
+ expect(sw.channel.close()).andReturn(null);
+ replay(sw.channel);
+ sw.deliverRoleRequestNotSupported(pending.xid+1);
+ verify(sw.channel);
+ assertEquals(null, sw.role);
+ assertEquals(0, sw.pendingRoleRequests.size());
+ }
+}