package net.floodlightcontroller.core.internal;

import static org.easymock.EasyMock.capture;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.floodlightcontroller.core.FloodlightContext;
import net.floodlightcontroller.core.IFloodlightProviderService.Role;
import net.floodlightcontroller.core.IOFSwitch;
import net.floodlightcontroller.core.internal.OFChannelHandler.RoleRecvStatus;
import net.floodlightcontroller.debugcounter.DebugCounter;
import net.floodlightcontroller.debugcounter.IDebugCounterService;
import net.floodlightcontroller.threadpool.IThreadPoolService;

import org.easymock.Capture;
import org.easymock.CaptureType;
import org.easymock.EasyMock;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.projectfloodlight.openflow.protocol.OFDescStatsReply;
import org.projectfloodlight.openflow.protocol.OFExperimenter;
import org.projectfloodlight.openflow.protocol.OFFactories;
import org.projectfloodlight.openflow.protocol.OFFactory;
import org.projectfloodlight.openflow.protocol.OFFeaturesReply;
import org.projectfloodlight.openflow.protocol.OFGetConfigReply;
import org.projectfloodlight.openflow.protocol.OFHelloElem;
import org.projectfloodlight.openflow.protocol.OFMessage;
import org.projectfloodlight.openflow.protocol.OFNiciraControllerRole;
import org.projectfloodlight.openflow.protocol.OFPacketIn;
import org.projectfloodlight.openflow.protocol.OFPacketInReason;
import org.projectfloodlight.openflow.protocol.OFPortDescStatsReply;
import org.projectfloodlight.openflow.protocol.OFSetConfig;
import org.projectfloodlight.openflow.protocol.OFStatsReply;
import org.projectfloodlight.openflow.protocol.OFStatsRequest;
import org.projectfloodlight.openflow.protocol.OFStatsType;
import org.projectfloodlight.openflow.protocol.OFType;
import org.projectfloodlight.openflow.protocol.OFVersion;
import org.projectfloodlight.openflow.types.DatapathId;
import org.projectfloodlight.openflow.types.U32;

/**
 * Channel handler deals with the switch connection and dispatches
 * switch messages to the appropriate locations. These Unit Testing cases
 * test the channeler state machine and role changer. In the first release,
 * we will focus on OF version 1.0. we will add the testing case for
 * version 1.3 later.
 */
public class OFChannelHandlerTest {
    private Controller controller;
    private IThreadPoolService threadPool;
    private IDebugCounterService debugCounterService;
    private OFChannelHandler handler;
    private Channel channel;
    private ChannelHandlerContext ctx;
    private MessageEvent messageEvent;
    private ChannelStateEvent channelStateEvent;
    private ChannelPipeline pipeline;
    private Capture<ExceptionEvent> exceptionEventCapture;
    private Capture<List<OFMessage>> writeCapture;
    private OFFeaturesReply featuresReply;
    private Set<Integer> seenXids = null;
    private OFSwitchImplBase swImplBase;
    private OFVersion ofVersion = OFVersion.OF_10;
    private OFFactory factory13;
    private OFFactory factory10;
    private OFFactory factory;

    @Before
    public void setUp() throws Exception {
        controller = createMock(Controller.class);
        threadPool = createMock(IThreadPoolService.class);
        ctx = createMock(ChannelHandlerContext.class);
        channelStateEvent = createMock(ChannelStateEvent.class);
        channel = createMock(Channel.class);
        messageEvent = createMock(MessageEvent.class);
        exceptionEventCapture = new Capture<ExceptionEvent>(CaptureType.ALL);
        pipeline = createMock(ChannelPipeline.class);
        writeCapture = new Capture<List<OFMessage>>(CaptureType.ALL);
        swImplBase = createMock(OFSwitchImplBase.class);
        seenXids = null;
        factory13 = OFFactories.getFactory(OFVersion.OF_13);
        factory10 = OFFactories.getFactory(OFVersion.OF_10);
        factory = (ofVersion == OFVersion.OF_13) ? factory13 : factory10;

        // TODO: should mock IDebugCounterService and make sure
        // the expected counters are updated.
        debugCounterService = new DebugCounter();
        Controller.Counters counters =
                new Controller.Counters();
        counters.createCounters(debugCounterService);
        expect(controller.getCounters()).andReturn(counters).anyTimes();
        expect(controller.getOFMessageFactory_10()).andReturn(factory10)
            .anyTimes();
        expect(controller.getOFMessageFactory_13()).andReturn(factory13)
            .anyTimes();
        expect(controller.addConnectedSwitch(2000,handler)).andReturn(true)
            .anyTimes();
        replay(controller);
        handler = new OFChannelHandler(controller);
        verify(controller);
        reset(controller);

        resetChannel();

        // thread pool is usually not called, so start empty replay
        replay(threadPool);

        // replay controller. Reset it if you need more specific behavior
        replay(controller);

        // replay switch. Reset it if you need more specific behavior
        replay(swImplBase);

        // Mock ctx and channelStateEvent
        expect(ctx.getChannel()).andReturn(channel).anyTimes();
        expect(channelStateEvent.getChannel()).andReturn(channel).anyTimes();
        replay(ctx, channelStateEvent);

        /* Setup an exception event capture on the channel. Right now
         * we only expect exception events to be send up the channel.
         * However, it's easy to extend to other events if we need it
         */
        pipeline.sendUpstream(capture(exceptionEventCapture));
        expectLastCall().anyTimes();
        replay(pipeline);
        featuresReply = (OFFeaturesReply)buildOFMessage(OFType.FEATURES_REPLY);
    }

    @After
    public void tearDown() {
        /* ensure no exception was thrown */
        if (exceptionEventCapture.hasCaptured()) {
            Throwable ex = exceptionEventCapture.getValue().getCause();
            throw new AssertionError("Unexpected exception: " +
                    ex.getClass().getName() + "(" + ex + ")");
        }
        assertFalse("Unexpected messages have been captured",
                writeCapture.hasCaptured());
        // verify all mocks.
        verify(channel);
        verify(messageEvent);
        verify(controller);
        verify(threadPool);
        verify(ctx);
        verify(channelStateEvent);
        verify(pipeline);
        verify(swImplBase);

    }

    /** Reset the channel mock and set basic method call expectations */
    void resetChannel() {
        reset(channel);
        expect(channel.getPipeline()).andReturn(pipeline).anyTimes();
        expect(channel.getRemoteAddress()).andReturn(null).anyTimes();
    }

    /** reset, setup, and replay the messageEvent mock for the given
     * messages
     */
    void setupMessageEvent(List<OFMessage> messages) {
        reset(messageEvent);
        expect(messageEvent.getMessage()).andReturn(messages).atLeastOnce();
        replay(messageEvent);
    }

    /** reset, setup, and replay the messageEvent mock for the given
     * messages, mock controller  send message to channel handler
     *
     * This method will reset, start replay on controller, and then verify
     */
    void sendMessageToHandlerWithControllerReset(List<OFMessage> messages)
            throws Exception {
        verify(controller);
        reset(controller);

        sendMessageToHandlerNoControllerReset(messages);
    }

    /** reset, setup, and replay the messageEvent mock for the given
     * messages, mock controller  send message to channel handler
     *
     * This method will start replay on controller, and then verify
     */
    void sendMessageToHandlerNoControllerReset(List<OFMessage> messages)
            throws Exception {
        setupMessageEvent(messages);

        // mock controller
        controller.flushAll();
        expectLastCall().anyTimes();
        expect(controller.addConnectedSwitch(1000, handler))
        .andReturn(true).anyTimes();
        replay(controller);

        handler.messageReceived(ctx, messageEvent);
        verify(controller);
    }

    /**
     * Extract the list of OFMessages that was captured by the Channel.write()
     * capture. Will check that something was actually captured first. We'll
     * collapse the messages from multiple writes into a single list of
     * OFMessages.
     * Resets the channelWriteCapture.
     */
    List<OFMessage> getMessagesFromCapture() {
        List<OFMessage> msgs = new ArrayList<OFMessage>();

        assertTrue("No write on channel was captured",
                writeCapture.hasCaptured());
        List<List<OFMessage>> capturedVals = writeCapture.getValues();

        for (List<OFMessage> oneWriteList: capturedVals)
            msgs.addAll(oneWriteList);
        writeCapture.reset();
        return msgs;
    }


    /**
     * Verify that the given exception event capture (as returned by
     * getAndInitExceptionCapture) has thrown an exception of the given
     * expectedExceptionClass.
     * Resets the capture
     */
    void verifyExceptionCaptured(
            Class<? extends Throwable> expectedExceptionClass) {
        assertTrue("Excpected exception not thrown",
                exceptionEventCapture.hasCaptured());
        Throwable caughtEx = exceptionEventCapture.getValue().getCause();
        assertEquals(expectedExceptionClass, caughtEx.getClass());
        exceptionEventCapture.reset();
    }

    /**
     * Make sure that the transaction ids in the given messages are
     * not 0 and differ between each other.
     * While it's not a defect per se if the xids are we want to ensure
     * we use different ones for each message we send.
     */
    void verifyUniqueXids(List<OFMessage> msgs) {
        if (seenXids == null)
            seenXids = new HashSet<Integer>();
        for (OFMessage m: msgs)  {
            int xid = (int)m.getXid();
            assertTrue("Xid in messags is 0", xid != 0);
            assertFalse("Xid " + xid + " has already been used",
                    seenXids.contains(xid));
            seenXids.add(xid);
        }
    }


    @Test
    public void testInitState() throws Exception {
        OFMessage m = buildOFMessage(OFType.HELLO);

        expect(messageEvent.getMessage()).andReturn(null);
        replay(channel, messageEvent);

        // We don't expect to receive /any/ messages in init state since
        // channelConnected moves us to a different state
        sendMessageToHandlerWithControllerReset(Collections.singletonList(m));

        verifyExceptionCaptured(SwitchStateException.class);
        assertEquals(OFChannelHandler.ChannelState.INIT,
                handler.getStateForTesting());
    }

    /**
     * move the channel from scratch to WAIT_HELLO state
     *
     */
    @Test
    public void moveToWaitHello() throws Exception {
        resetChannel();
        channel.write(capture(writeCapture));
        expectLastCall().andReturn(null).once();
        replay(channel);
        // replay unused mocks
        replay(messageEvent);

        handler.channelConnected(ctx, channelStateEvent);

        List<OFMessage> msgs = getMessagesFromCapture();
        assertEquals(1, msgs.size());
        assertEquals(OFType.HELLO, msgs.get(0).getType());
        assertEquals(OFChannelHandler.ChannelState.WAIT_HELLO,
                handler.getStateForTesting());
        //Should verify that the Hello received from the controller
        //is ALWAYS OF1.3 hello regardless of the switch version
        assertEquals(OFVersion.OF_13, msgs.get(0).getVersion());
        verifyUniqueXids(msgs);
    }


    /**
     * Move the channel from scratch to WAIT_FEATURES_REPLY state
     * Builds on moveToWaitHello()
     * adds testing for WAIT_HELLO state
     */
    @Test
    public void moveToWaitFeaturesReply() throws Exception {
        moveToWaitHello();
        resetChannel();
        channel.write(capture(writeCapture));
        expectLastCall().andReturn(null).atLeastOnce();
        replay(channel);

        OFMessage hello = buildOFMessage(OFType.HELLO);
        sendMessageToHandlerWithControllerReset(Collections.singletonList(hello));

        List<OFMessage> msgs = getMessagesFromCapture();
        assertEquals(1, msgs.size());
        assertEquals(OFType.FEATURES_REQUEST, msgs.get(0).getType());
        if (ofVersion == OFVersion.OF_10) {
            assertEquals(OFVersion.OF_10, msgs.get(0).getVersion());
        }
        verifyUniqueXids(msgs);

        assertEquals(OFChannelHandler.ChannelState.WAIT_FEATURES_REPLY,
                handler.getStateForTesting());
    }

    /**
     * Move the channel from scratch to WAIT_CONFIG_REPLY state
     * Builds on moveToWaitFeaturesReply
     * adds testing for WAIT_FEATURES_REPLY state
     */
    @Test
    public void moveToWaitConfigReply() throws Exception {
        moveToWaitFeaturesReply();

        resetChannel();
        channel.write(capture(writeCapture));
        expectLastCall().andReturn(null).atLeastOnce();
        replay(channel);

        sendMessageToHandlerWithControllerReset(Collections.<OFMessage>singletonList(featuresReply));
        List<OFMessage> msgs = getMessagesFromCapture();
        assertEquals(3, msgs.size());
        assertEquals(OFType.SET_CONFIG, msgs.get(0).getType());
        OFSetConfig sc = (OFSetConfig)msgs.get(0);
        assertEquals((short)0xffff, sc.getMissSendLen());
        assertEquals(OFType.BARRIER_REQUEST, msgs.get(1).getType());
        assertEquals(OFType.GET_CONFIG_REQUEST, msgs.get(2).getType());
        verifyUniqueXids(msgs);
        assertEquals(OFChannelHandler.ChannelState.WAIT_CONFIG_REPLY,
                handler.getStateForTesting());
    }

    /**
     * Move the channel from scratch to WAIT_DESCRIPTION_STAT_REPLY state
     * Builds on moveToWaitConfigReply()
     * adds testing for WAIT_CONFIG_REPLY state
     */
    @Test
    public void moveToWaitDescriptionStatReply() throws Exception {
        moveToWaitConfigReply();
        resetChannel();
        channel.write(capture(writeCapture));
        expectLastCall().andReturn(null).atLeastOnce();
        replay(channel);

        OFGetConfigReply cr = (OFGetConfigReply)buildOFMessage(OFType.GET_CONFIG_REPLY);

        sendMessageToHandlerWithControllerReset(Collections.<OFMessage>singletonList(cr));

        List<OFMessage> msgs = getMessagesFromCapture();
        assertEquals(1, msgs.size());
        assertEquals(OFType.STATS_REQUEST, msgs.get(0).getType());
        OFStatsRequest<?> sr = (OFStatsRequest<?>) msgs.get(0);
        assertEquals(OFStatsType.DESC, sr.getStatsType());
        verifyUniqueXids(msgs);
        assertEquals(OFChannelHandler.ChannelState.WAIT_DESCRIPTION_STAT_REPLY,
                handler.getStateForTesting());
    }


    private OFStatsReply createDescriptionStatsReply() throws IOException {
        OFStatsReply sr = (OFStatsReply)buildOFMessage(OFType.STATS_REPLY);
        return sr;
    }

    /**
     * Move the channel from scratch to WAIT_INITIAL_ROLE state
     * for a switch that does not have a sub-handshake
     * Builds on moveToWaitDescriptionStatReply()
     * adds testing for WAIT_DESCRIPTION_STAT_REPLY state
     *
     */
    @Test
    public void moveToWaitInitialRole()
            throws Exception {
        moveToWaitDescriptionStatReply();

        long xid = 2000;

        // build the stats reply
        OFStatsReply sr = createDescriptionStatsReply();

        resetChannel();
        replay(channel);

        setupMessageEvent(Collections.<OFMessage>singletonList(sr));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr,ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();
        controller.submitRegistryRequest(1000);
        expectLastCall().once();
        controller.flushAll();
        expectLastCall().once();
        replay(controller);

        //TODO: With the description stats message you are sending in the test,
        //you will end up with an OFSwitchImplBase object
        //which by default does NOT support the nicira role messages.
        //If you wish to test the case where Nicira role messages are supported,
        //then make a comment here that states that this is different
        //from the default behavior of switchImplbase /or/
        //send the right desc-stats (for example send what is expected from OVS 1.0)

        if (ofVersion == OFVersion.OF_10) {
            expect(swImplBase.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
            .andReturn(true).once();

            swImplBase.write(capture(writeCapture),
                    EasyMock.<FloodlightContext>anyObject());
            expectLastCall().anyTimes();
        }

        swImplBase.setOFVersion(ofVersion);
        expectLastCall().once();
        swImplBase.setConnected(true);
        expectLastCall().once();
        swImplBase.setChannel(channel);
        expectLastCall().once();
        swImplBase.setFloodlightProvider(controller);
        expectLastCall().once();
        swImplBase.setThreadPoolService(controller.getThreadPoolService());
        expectLastCall().once();
        swImplBase.setDebugCounterService(controller.getDebugCounter());
        expectLastCall().once();
        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        swImplBase.setRole(Role.EQUAL);
        expectLastCall().once();

        expect(swImplBase.getNextTransactionId())
        .andReturn((int)xid).anyTimes();
        expect(swImplBase.getId())
        .andReturn(1000L).once();

        swImplBase.setFeaturesReply(featuresReply);
        expectLastCall().once();
        swImplBase.setPortDescReply((OFPortDescStatsReply)null );
        swImplBase.setPortDescReplies((List<OFPortDescStatsReply>)null );
        replay(swImplBase);

        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);

        List<OFMessage> msgs = getMessagesFromCapture();
        assertEquals(1, msgs.size());
        assertEquals(OFType.EXPERIMENTER, msgs.get(0).getType());
        verifyNiciraMessage((OFExperimenter)msgs.get(0));

        verify(controller);
        assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                handler.getStateForTesting());
    }

    /**
     * Move the channel from scratch to
     *  WAIT_SWITCH_DRIVER_SUB_HANDSHAKE state
     * Builds on moveToWaitInitialRole()
     */
    @Test
    public void moveToWaitSubHandshake()
            throws Exception {
        moveToWaitInitialRole();

        int xid = 2000;
        resetChannel();
        replay(channel);

        reset(swImplBase);
        // Set the role
        setupSwitchSendRoleRequestAndVerify(true, xid, Role.SLAVE);
        assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                handler.getStateForTesting());

        OFMessage rr = getRoleReply(xid, Role.SLAVE);
        setupMessageEvent(Collections.<OFMessage>singletonList(rr));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        controller.flushAll();
        expectLastCall().once();

        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        swImplBase.setRole(Role.SLAVE);
        expectLastCall().once();
        expect(swImplBase.getNextTransactionId())
        .andReturn(xid).anyTimes();
        swImplBase.startDriverHandshake();
        expectLastCall().once();

        //when this flag is false, state machine will move to
        //WAIT_SWITCH_DRIVER_SUB_HANDSHAKE state
        expect(swImplBase.isDriverHandshakeComplete())
        .andReturn(false).once();

        replay(swImplBase);

        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);

        assertEquals(OFChannelHandler.ChannelState.WAIT_SWITCH_DRIVER_SUB_HANDSHAKE,
                handler.getStateForTesting());
    }

    /**
     * In WAIT_INITIAL_ROLE state the controller is waiting to hear back from
     * the registry service. If it gets mastership it sends a role-request to
     * the switch and if it gets the reply it moves to state MASTER.
     * <p>
     * However if it does not hear from the registry service, the handshake
     * process should timeout, and the controller should move to state EQUAL.
     * This test checks this behavior.
     *
     * @throws Exception
     */
    @Test
    public void moveToRoleEqualFromHandshakeTimeout() throws Exception {
        moveToWaitInitialRole();
        int xid = 2000;
        resetChannel();
        reset(controller);
        reset(swImplBase);
        // simulate that we never heard from registry service and so the
        // handshake times out -- this results in a HandshakeTimeoutException
        // called on the channel.
        ExceptionEvent eeMock = createMock(ExceptionEvent.class);
        expect(eeMock.getCause()).andReturn(new HandshakeTimeoutException())
                .atLeastOnce();
        // controller should move to role EQUAL via the driver handshake
        swImplBase.setRole(Role.EQUAL);
        expectLastCall().once();
        swImplBase.startDriverHandshake();
        expectLastCall().once();
        // assume nothing-to-do in driver handshake by returning true
        // immediately
        expect(swImplBase.isDriverHandshakeComplete())
                .andReturn(true).once();
        expect(swImplBase.getRole()).andReturn(Role.EQUAL).once();
        expect(swImplBase.getId())
                .andReturn(1L).anyTimes();
        expect(controller.addActivatedEqualSwitch(1L, swImplBase))
                .andReturn(true).once();

        replay(channel);
        replay(controller);
        replay(swImplBase);
        replay(eeMock);
        handler.exceptionCaught(ctx, eeMock);
        assertEquals(OFChannelHandler.ChannelState.EQUAL,
                handler.getStateForTesting());
    }


    /**
     * Move the channel from scratch to WAIT_INITIAL_ROLE state,
     * then move the channel to EQUAL state based on the switch Role.
     * This test basically test the switch with role support.
     * Builds on moveToWaitInitialRole().
     *
     * In WAIT_INITIAL_ROLE state, when any messages (except ECHO_REQUEST
     * and PORT_STATUS), state machine will transit to MASTER or
     * EQUAL state based on the switch role.
     */
    @Test
    public void moveToSlaveWithHandshakeComplete()
            throws Exception {

        moveToWaitInitialRole();

        int xid = 2000;
        resetChannel();
        replay(channel);

        reset(swImplBase);
        // Set the role
        setupSwitchSendRoleRequestAndVerify(true, xid, Role.SLAVE);
        assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                handler.getStateForTesting());

        // build the stats reply
        OFStatsReply sr = createDescriptionStatsReply();
        OFMessage rr = getRoleReply(xid, Role.SLAVE);
        setupMessageEvent(Collections.<OFMessage>singletonList(rr));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr, ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        controller.flushAll();
        expectLastCall().once();
        expect(controller.addActivatedEqualSwitch(1000, swImplBase))
        .andReturn(true).once();
        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        //consult the role in sw to determine the next state.
        //in this testing case, we are testing that channel handler
        // will move to EQUAL state when switch role is in SLAVE.
        expect(swImplBase.getRole()).andReturn(Role.SLAVE).once();
        swImplBase.setRole(Role.SLAVE);
        expectLastCall().once();

        expect(swImplBase.getNextTransactionId())
        .andReturn(xid).anyTimes();
        expect(swImplBase.getId())
        .andReturn(1000L).once();
        swImplBase.startDriverHandshake();
        expectLastCall().once();

        //when this flag is true, don't need to move interim state
        //WAIT_SWITCH_DRIVER_SUB_HANDSHAKE. channel handler will
        //move to corresponding state after consulting the role in sw
        //This is essentially the same test as the one above,
        //except for this line
        expect(swImplBase.isDriverHandshakeComplete())
        .andReturn(true).once();

        replay(swImplBase);

        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);

        assertEquals(OFChannelHandler.ChannelState.EQUAL,
                handler.getStateForTesting());
    }

    /**
     * Move the channel from scratch to WAIT_INITIAL_ROLE state,
     * then to MASTERL state based on the switch Role.
     * This test basically test the switch with role support.
     * Builds on moveToWaitInitialRole().
     *
     * In WAIT_INITIAL_ROLE state, when any messages (except ECHO_REQUEST
     * and PORT_STATUS), state machine will transit to MASTER or
     * EQUAL state based on the switch role.
     */
    @Test
    public void moveToMasterWithHandshakeComplete()
            throws Exception {

        moveToWaitInitialRole();

        int xid = 2000;
        resetChannel();
        replay(channel);

        reset(swImplBase);
        // Set the role
        setupSwitchSendRoleRequestAndVerify(true, xid, Role.MASTER);
        assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                handler.getStateForTesting());

        // build the stats reply
        OFStatsReply sr = createDescriptionStatsReply();
        OFMessage rr = getRoleReply(xid, Role.MASTER);
        setupMessageEvent(Collections.<OFMessage>singletonList(rr));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr, ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        controller.flushAll();
        expectLastCall().once();
        expect(controller.addActivatedMasterSwitch(1000, swImplBase))
        .andReturn(true).once();
        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        expect(swImplBase.getRole()).andReturn(Role.MASTER).once();
        swImplBase.setRole(Role.MASTER);
        expectLastCall().once();

        expect(swImplBase.getNextTransactionId())
        .andReturn(xid).anyTimes();
        expect(swImplBase.getId())
        .andReturn(1000L).once();
        swImplBase.startDriverHandshake();
        expectLastCall().once();
        expect(swImplBase.isDriverHandshakeComplete())
        .andReturn(true).once();

        replay(swImplBase);


        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);

        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());
    }

    /**
     * Move the channel from scratch to
     *  WAIT_SWITCH_DRIVER_SUB_HANDSHAKE state
     * Builds on moveToWaitSubHandshake()
     */
    @Test
    public void moveToEqualViaWaitSubHandshake()
            throws Exception {
        moveToWaitSubHandshake();

        long xid = 2000;
        resetChannel();
        replay(channel);

        // build the stats reply
        OFStatsReply sr = createDescriptionStatsReply();

        setupMessageEvent(Collections.<OFMessage>singletonList(sr));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr, ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        controller.flushAll();
        expectLastCall().once();
        expect(controller.addActivatedEqualSwitch(1000, swImplBase))
        .andReturn(true).once();
        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        expect(swImplBase.getRole()).andReturn(Role.SLAVE).once();
        expect(swImplBase.getNextTransactionId())
        .andReturn((int)xid).anyTimes();
        expect(swImplBase.getId())
        .andReturn(1000L).once();

        swImplBase.processDriverHandshakeMessage(sr);
        expectLastCall().once();
        expect(swImplBase.isDriverHandshakeComplete())
        .andReturn(true).once();

        replay(swImplBase);

        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);

        assertEquals(OFChannelHandler.ChannelState.EQUAL,
                handler.getStateForTesting());
    }

    /**
     * Move the channel from scratch to
     *  WAIT_SWITCH_DRIVER_SUB_HANDSHAKE state
     * Builds on moveToWaitSubHandshake()
     */
    @Test
    public void moveToMasterViaWaitSubHandshake()
            throws Exception {
        moveToWaitSubHandshake();

        long xid = 2000;
        resetChannel();
        replay(channel);

        // In this state, any messages except echo request, port status and
        // error go to the switch sub driver handshake. Once the switch reports
        // that its sub driver handshake is complete (#isDriverHandshakeComplete
        // return true) then the channel handle consults the switch role and
        // moves the state machine to the appropriate state (MASTER or EQUALS).
        // In this test we expect the state machine to end up in MASTER state.
        OFStatsReply sr = createDescriptionStatsReply();

        setupMessageEvent(Collections.<OFMessage>singletonList(sr));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr, ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        controller.flushAll();
        expectLastCall().once();
        expect(controller.addActivatedMasterSwitch(1000, swImplBase))
        .andReturn(true).once();
        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        expect(swImplBase.getRole()).andReturn(Role.MASTER).once();
        expect(swImplBase.getNextTransactionId())
        .andReturn((int)xid).anyTimes();
        expect(swImplBase.getId())
        .andReturn(1000L).once();

        swImplBase.processDriverHandshakeMessage(sr);
        expectLastCall().once();
        expect(swImplBase.isDriverHandshakeComplete())
        .andReturn(true).once();

        replay(swImplBase);

        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);
        verify(controller);
        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());
    }

    /**
     * Test the behavior in WAIT_SWITCH_DRIVER_SUB_HANDSHAKE state.
     * ECHO_REQUEST message received case
     */
    @Test
    public void testWaitSwitchDriverSubhandshake() throws Exception {
        moveToWaitSubHandshake();

        long xid = 2000;
        resetChannel();
        channel.write(capture(writeCapture));
        expectLastCall().andReturn(null).atLeastOnce();
        replay(channel);

        OFMessage er = buildOFMessage(OFType.ECHO_REQUEST);

        setupMessageEvent(Collections.<OFMessage>singletonList(er));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        controller.flushAll();
        expectLastCall().once();

        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        expect(swImplBase.getNextTransactionId())
        .andReturn((int)xid).anyTimes();

        replay(swImplBase);

        handler.messageReceived(ctx, messageEvent);

        List<OFMessage> msgs = getMessagesFromCapture();
        assertEquals(1, msgs.size());
        assertEquals(OFType.ECHO_REPLY, msgs.get(0).getType());
        verifyUniqueXids(msgs);
        assertEquals(OFChannelHandler.ChannelState.WAIT_SWITCH_DRIVER_SUB_HANDSHAKE,
                handler.getStateForTesting());
    }

    /**
     * Helper
     * Verify that the given OFMessage is a correct Nicira RoleRequest message
     */
    private void verifyNiciraMessage(OFExperimenter ofMessage) {

        int vendor = (int) ofMessage.getExperimenter();
        assertEquals(vendor, 0x2320);// magic number representing nicira
    }

    /**
     * Setup the mock switch and write capture for a role request, set the
     * role and verify mocks.
     * @param supportsNxRole whether the switch supports role request messages
     * to setup the attribute. This must be null (don't yet know if roles
     * supported: send to check) or true.
     * @param xid The xid to use in the role request
     * @param role The role to send
     * @throws IOException
     */
    private void setupSwitchSendRoleRequestAndVerify(Boolean supportsNxRole,
            int xid,
            Role role) throws IOException {

        RoleRecvStatus expectation = RoleRecvStatus.MATCHED_SET_ROLE;

        expect(swImplBase.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
        .andReturn(supportsNxRole).atLeastOnce();

        if (supportsNxRole != null && supportsNxRole) {
            expect(swImplBase.getNextTransactionId()).andReturn(xid).once();
            swImplBase.write(capture(writeCapture),
                    EasyMock.<FloodlightContext>anyObject());
            expectLastCall().anyTimes();
        }
        replay(swImplBase);

        handler.sendRoleRequest(role, expectation);

        if (supportsNxRole != null && supportsNxRole) {
            List<OFMessage> msgs = getMessagesFromCapture();
            assertEquals(1, msgs.size());
            verifyNiciraMessage((OFExperimenter)msgs.get(0));
        }
    }

    /**
     * Setup the mock switch for a role change request where the switch
     * does not support roles.
     *
     * Needs to verify and reset the controller since we need to set
     * an expectation
     */
    private void setupSwitchRoleChangeUnsupported(int xid,
            Role role) {
        boolean supportsNxRole = false;
        RoleRecvStatus expectation = RoleRecvStatus.NO_REPLY;
        reset(swImplBase);
        expect(swImplBase.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
        .andReturn(supportsNxRole).atLeastOnce();
        // TODO: hmmm. While it's not incorrect that we set the attribute
        // again it looks odd. Maybe change
        swImplBase.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, supportsNxRole);
        expectLastCall().anyTimes();

        replay(swImplBase);

        handler.sendRoleRequest(role, expectation);

        verify(swImplBase);
    }

    /*
     * Return a Nicira RoleReply message for the given role
     */
    private OFMessage getRoleReply(long xid, Role role) {

        OFNiciraControllerRole nr = null;

        switch(role) {
        case MASTER:
            nr = OFNiciraControllerRole.ROLE_MASTER;
            break;
        case EQUAL:
            nr = OFNiciraControllerRole.ROLE_SLAVE;
            break;
        case SLAVE:
            nr = OFNiciraControllerRole.ROLE_SLAVE;
            break;
        default: //handled below
        }
        OFMessage m = factory10.buildNiciraControllerRoleReply()
                .setRole(nr)
                .setXid(xid)
                .build();
        return m;
    }

    /**
     * Move the channel from scratch to MASTER state
     * Builds on moveToWaitInitialRole()
     * adds testing for WAIT_INITAL_ROLE state
     *
     * This method tests the case that the switch does NOT support roles.
     * In ONOS if the switch-driver says that nicira-role messages are not
     * supported, then ONOS does NOT send role-request messages
     * (see handleUnsentRoleMessage())
     */
    @Test
    public void testInitialMoveToMasterNoRole() throws Exception {
        int xid = 43;
        // first, move us to WAIT_INITIAL_ROLE_STATE

        moveToWaitInitialRole();
        assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                handler.getStateForTesting());

        OFStatsReply sr = createDescriptionStatsReply();

        reset(controller);
        reset(swImplBase);

        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr, ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        expect(controller.addActivatedMasterSwitch(1000, swImplBase))
        .andReturn(true).once();
        replay(controller);

        reset(swImplBase);
        swImplBase.setRole(Role.MASTER);
        expectLastCall().once();
        swImplBase.startDriverHandshake();
        expectLastCall().once();
        expect(swImplBase.isDriverHandshakeComplete())
        .andReturn(true).once();
        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        expect(swImplBase.getRole()).andReturn(Role.MASTER).once();

        expect(swImplBase.getId())
        .andReturn(1000L).once();
        // Set the role
        setupSwitchSendRoleRequestAndVerify(false, xid, Role.MASTER);

        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());
    }

    /**
     * Move the channel from scratch to WAIT_INITIAL_ROLE state
     * Builds on moveToWaitInitialRole()
     * adds testing for WAIT_INITAL_ROLE state
     *
     * We let the initial role request time out. Role support should be
     * disabled but the switch should be activated.
     */
    /* TBD
        @Test
        public void testInitialMoveToMasterTimeout() throws Exception {
            int timeout = 50;
            handler.useRoleChangerWithOtherTimeoutForTesting(timeout);
            int xid = 4343;

            // first, move us to WAIT_INITIAL_ROLE_STATE

            moveToWaitInitialRole();
            assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                    handler.getStateForTesting());

            // prepare mocks and inject the role reply message
            reset(swImplBase);
            // Set the role
            swImplBase.setRole(Role.MASTER);
            expectLastCall().once();
            swImplBase.startDriverHandshake();
            expectLastCall().once();
            expect(swImplBase.isDriverHandshakeComplete())
            .andReturn(false).once();
            if (ofVersion == OFVersion.OF_10) {
                expect(swImplBase.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                 .andReturn(true).once();

                swImplBase.write(capture(writeCapture),
                        EasyMock.<FloodlightContext>anyObject());
                expectLastCall().anyTimes();
             }
            expect(swImplBase.getNextTransactionId()).andReturn(xid).once();

            assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                    handler.getStateForTesting());

            // Set the role
            setupSwitchSendRoleRequestAndVerify(null, xid, Role.MASTER);
            assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                    handler.getStateForTesting());

            OFMessage m = buildOFMessage(OFType.ECHO_REPLY);

            setupMessageEvent(Collections.<OFMessage>singletonList(m));

            Thread.sleep(timeout+5);

            verify(controller);
            reset(controller);

            expect(controller.addActivatedMasterSwitch(1000, swImplBase))
            .andReturn(true).once();
            controller.flushAll();
            expectLastCall().once();

            replay(controller);

            handler.messageReceived(ctx, messageEvent);

            assertEquals(OFChannelHandler.ChannelState.MASTER,
                    handler.getStateForTesting());

        }

     */
    /**
     * Move the channel from scratch to SLAVE state
     * Builds on doMoveToWaitInitialRole()
     * adds testing for WAIT_INITAL_ROLE state
     *
     * This method tests the case that the switch does NOT support roles.
     * The channel handler still needs to send the initial request to find
     * out that whether the switch supports roles.
     *
     */
    @Test
    public void testInitialMoveToSlaveNoRole() throws Exception {
        int xid = 44;
        // first, move us to WAIT_INITIAL_ROLE_STATE
        moveToWaitInitialRole();
        assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                handler.getStateForTesting());

        reset(swImplBase);
        // Set the role
        setupSwitchSendRoleRequestAndVerify(false, xid, Role.SLAVE);
        assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                handler.getStateForTesting());

    }

    /**
     * Move the channel from scratch to SLAVE state
     * Builds on doMoveToWaitInitialRole()
     * adds testing for WAIT_INITAL_ROLE state
     *
     * We let the initial role request time out. The switch should be
     * disconnected
     */
    /* TBD
        @Test
        public void testInitialMoveToSlaveTimeout() throws Exception {
            int timeout = 50;
            handler.useRoleChangerWithOtherTimeoutForTesting(timeout);
            int xid = 4444;

            // first, move us to WAIT_INITIAL_ROLE_STATE
            moveToWaitInitialRole();
            assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                    handler.getStateForTesting());

            // Set the role
            setupSwitchSendRoleRequestAndVerify(null, xid, Role.SLAVE);
            assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                    handler.getStateForTesting());

            // prepare mocks and inject the role reply message
            reset(sw);
            sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, false);
            expectLastCall().once();
            sw.setRole(Role.SLAVE);
            expectLastCall().once();
            sw.disconnectSwitch(); // Make sure we disconnect
            expectLastCall().once();
            replay(sw);

            OFMessage m = buildOFMessage(OFType.ECHO_REPLY);

            Thread.sleep(timeout+5);

            sendMessageToHandlerWithControllerReset(Collections.singletonList(m));
        }

     */
    /**
     * Move channel from scratch to WAIT_INITIAL_STATE, then MASTER,
     * then SLAVE for cases where the switch does not support roles.
     * I.e., the final SLAVE transition should disconnect the switch.
     */
    @Test
    public void testNoRoleInitialToMasterToSlave() throws Exception {
        int xid = 46;
        reset(swImplBase);
        replay(swImplBase);

        reset(controller);
        replay(controller);

        // First, lets move the state to MASTER without role support
        testInitialMoveToMasterNoRole();
        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());

        // try to set master role again. should be a no-op
        setupSwitchRoleChangeUnsupported(xid, Role.MASTER);

        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());

        setupSwitchRoleChangeUnsupported(xid, Role.SLAVE);
        //switch does not support role message. there is no role set
        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());

    }

    /**
     * Move the channel to MASTER state
     * Expects that the channel is in MASTER or SLAVE state.
     *
     */
    public void changeRoleToMasterWithRequest() throws Exception {
        int xid = 4242;

        assertTrue("This method can only be called when handler is in " +
                "MASTER or SLAVE role", handler.isHandshakeComplete());

        reset(swImplBase);
        reset(controller);
        // Set the role
        setupSwitchSendRoleRequestAndVerify(true, xid, Role.MASTER);

        // prepare mocks and inject the role reply message

        reset(controller);
        expect(controller.addActivatedMasterSwitch(1000, swImplBase))
        .andReturn(true).once();
        OFMessage reply = getRoleReply(xid, Role.MASTER);

        // sendMessageToHandler will verify and rest controller mock

        OFStatsReply sr = createDescriptionStatsReply();
        setupMessageEvent(Collections.<OFMessage>singletonList(reply));

        // mock controller
        reset(controller);
        reset(swImplBase);

        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr, ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();
        controller.transitionToMasterSwitch(1000);
        expectLastCall().once();

        controller.flushAll();
        expectLastCall().once();
        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        expect(swImplBase.getRole()).andReturn(Role.EQUAL).atLeastOnce();
        expect(swImplBase.getNextTransactionId())
        .andReturn(xid).anyTimes();
        expect(swImplBase.getId())
        .andReturn(1000L).once();

        swImplBase.setRole(Role.MASTER);
        expectLastCall().once();
        replay(swImplBase);

        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);

        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());
    }

    /**
     * Move the channel to SLAVE state
     * Expects that the channel is in MASTER or SLAVE state.
     *
     */
    public void changeRoleToSlaveWithRequest() throws Exception {
        int xid = 2323;

        assertTrue("This method can only be called when handler is in " +
                "MASTER or SLAVE role", handler.isHandshakeComplete());

        // Set the role
        reset(controller);
        reset(swImplBase);

        swImplBase.write(capture(writeCapture),
                EasyMock.<FloodlightContext>anyObject());
        expectLastCall().anyTimes();

        expect(swImplBase.getNextTransactionId())
        .andReturn(xid).anyTimes();


        if (ofVersion == OFVersion.OF_10) {
            expect(swImplBase.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
            .andReturn(true).once();

            swImplBase.write(capture(writeCapture),
                    EasyMock.<FloodlightContext>anyObject());
            expectLastCall().anyTimes();
        }
        replay(swImplBase);

        handler.sendRoleRequest(Role.SLAVE, RoleRecvStatus.MATCHED_SET_ROLE);

        List<OFMessage> msgs = getMessagesFromCapture();
        assertEquals(1, msgs.size());
        verifyNiciraMessage((OFExperimenter)msgs.get(0));


        OFMessage reply = getRoleReply(xid, Role.SLAVE);
        OFStatsReply sr = createDescriptionStatsReply();
        setupMessageEvent(Collections.<OFMessage>singletonList(reply));

        // mock controller
        reset(controller);
        reset(swImplBase);

        controller.transitionToEqualSwitch(1000);
        expectLastCall().once();
        expect(controller.getOFSwitchInstance((OFDescStatsReply)sr, ofVersion))
        .andReturn(swImplBase).anyTimes();
        expect(controller.getThreadPoolService())
        .andReturn(threadPool).anyTimes();
        expect(controller.getDebugCounter())
        .andReturn(debugCounterService).anyTimes();

        controller.flushAll();
        expectLastCall().once();
        replay(controller);

        expect(swImplBase.getStringId())
        .andReturn(null).anyTimes();
        expect(swImplBase.getRole()).andReturn(Role.MASTER).atLeastOnce();
        expect(swImplBase.getNextTransactionId())
        .andReturn(xid).anyTimes();

        // prepare mocks and inject the role reply message
        swImplBase.setRole(Role.EQUAL);
        expectLastCall().once();
        expect(swImplBase.getId())
        .andReturn(1000L).once();
        replay(swImplBase);

        handler.messageReceived(ctx, messageEvent);

        assertEquals(OFChannelHandler.ChannelState.EQUAL,
                handler.getStateForTesting());
    }

    @Test
    public void testMultiRoleChange1() throws Exception {
        moveToMasterWithHandshakeComplete();
        changeRoleToMasterWithRequest();
        changeRoleToSlaveWithRequest();
        changeRoleToSlaveWithRequest();
        changeRoleToMasterWithRequest();
        changeRoleToSlaveWithRequest();
    }

    @Test
    public void testMultiRoleChange2() throws Exception {
        moveToSlaveWithHandshakeComplete();
        changeRoleToMasterWithRequest();
        changeRoleToSlaveWithRequest();
        changeRoleToSlaveWithRequest();
        changeRoleToMasterWithRequest();
        changeRoleToSlaveWithRequest();
    }

    /**
     * Start from scratch and reply with an unexpected error to the role
     * change request
     * Builds on doMoveToWaitInitialRole()
     * adds testing for WAIT_INITAL_ROLE state
     */
    /* TBD
        @Test
        public void testInitialRoleChangeOtherError() throws Exception {
            int xid = 4343;
            // first, move us to WAIT_INITIAL_ROLE_STATE
            moveToWaitInitialRole();
            assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                    handler.getStateForTesting());

            reset(swImplBase);
            // Set the role
            setupSwitchSendRoleRequestAndVerify(true, xid, Role.MASTER);
            assertEquals(OFChannelHandler.ChannelState.WAIT_INITIAL_ROLE,
                    handler.getStateForTesting());


            // FIXME: shouldn't use ordinal(), but OFError is broken

            OFMessage err = factory.errorMsgs().buildBadActionErrorMsg()
                    .setCode(OFBadActionCode.BAD_LEN)
                    .setXid(2000)
                    .build();
            verify(swImplBase);
            reset(swImplBase);
            replay(swImplBase);
            sendMessageToHandlerWithControllerReset(Collections.singletonList(err));

            verifyExceptionCaptured(SwitchStateException.class);
        }
     */
    /**
     * Test dispatch of messages while in MASTER role
     */
    @Test
    public void testMessageDispatchMaster() throws Exception {

        moveToMasterWithHandshakeComplete();

        // Send packet in. expect dispatch
        OFPacketIn pi = (OFPacketIn)
                buildOFMessage(OFType.PACKET_IN);
        setupMessageEvent(Collections.<OFMessage>singletonList(pi));

        reset(controller);
        controller.handleMessage(swImplBase, pi, null);
        expectLastCall().once();
        controller.flushAll();
        expectLastCall().once();

        replay(controller);


        // send the description stats reply
        handler.messageReceived(ctx, messageEvent);

        assertEquals(OFChannelHandler.ChannelState.MASTER,
                handler.getStateForTesting());

        verify(controller);
        // TODO: many more to go
    }

    /**
     * Test port status message handling while MASTER
     *
     */
    /* Patrick: TBD
        @Test
        public void testPortStatusMessageMaster() throws Exception {
            long dpid = featuresReply.getDatapathId().getLong();
            testInitialMoveToMasterWithRole();
            List<OFPortDesc> ports = new ArrayList<OFPortDesc>();
            // A dummy port.
            OFPortDesc p = factory.buildPortDesc()
                        .setName("Eth1")
                        .setPortNo(OFPort.ofInt(1))
                        .build();
            ports.add(p);

            p.setName("Port1");
            p.setPortNumber((short)1);

            OFPortStatus ps = (OFPortStatus)buildOFMessage(OFType.PORT_STATUS);
            ps.setDesc(p);

            // The events we expect sw.handlePortStatus to return
            // We'll just use the same list for all valid OFPortReasons and add
            // arbitrary events for arbitrary ports that are not necessarily
            // related to the port status message. Our goal
            // here is not to return the correct set of events but the make sure
            // that a) sw.handlePortStatus is called
            //      b) the list of events sw.handlePortStatus returns is sent
            //         as IOFSwitchListener notifications.
            OrderedCollection<PortChangeEvent> events =
                    new LinkedHashSetWrapper<PortChangeEvent>();
            ImmutablePort p1 = ImmutablePort.create("eth1", (short)1);
            ImmutablePort p2 = ImmutablePort.create("eth2", (short)2);
            ImmutablePort p3 = ImmutablePort.create("eth3", (short)3);
            ImmutablePort p4 = ImmutablePort.create("eth4", (short)4);
            ImmutablePort p5 = ImmutablePort.create("eth5", (short)5);
            events.add(new PortChangeEvent(p1, PortChangeType.ADD));
            events.add(new PortChangeEvent(p2, PortChangeType.DELETE));
            events.add(new PortChangeEvent(p3, PortChangeType.UP));
            events.add(new PortChangeEvent(p4, PortChangeType.DOWN));
            events.add(new PortChangeEvent(p5, PortChangeType.OTHER_UPDATE));


            for (OFPortReason reason: OFPortReason.values()) {
                ps.setReason(reason.getReasonCode());

                reset(sw);
                expect(sw.getId()).andReturn(dpid).anyTimes();

                expect(sw.processOFPortStatus(ps)).andReturn(events).once();
                replay(sw);

                reset(controller);
                controller.notifyPortChanged(sw, p1, PortChangeType.ADD);
                controller.notifyPortChanged(sw, p2, PortChangeType.DELETE);
                controller.notifyPortChanged(sw, p3, PortChangeType.UP);
                controller.notifyPortChanged(sw, p4, PortChangeType.DOWN);
                controller.notifyPortChanged(sw, p5, PortChangeType.OTHER_UPDATE);
                sendMessageToHandlerNoControllerReset(
                        Collections.<OFMessage>singletonList(ps));
                verify(sw);
                verify(controller);
            }
        }

     */
    /**
     * Build an OF message
     * @throws IOException
     */
    private OFMessage buildOFMessage(OFType t) throws IOException {
        OFMessage m = null;
        switch (t) {

        case HELLO:
            // The OF protocol requires us to start things off by sending the highest
            // version of the protocol supported.

            // bitmap represents OF1.0 (ofp_version=0x01) and OF1.3 (ofp_version=0x04)
            // see Sec. 7.5.1 of the OF1.3.4 spec
            if (ofVersion == OFVersion.OF_13) {
                U32 bitmap = U32.ofRaw(0x00000012);
                OFHelloElem hem = factory13.buildHelloElemVersionbitmap()
                    .setBitmaps(Collections.singletonList(bitmap))
                    .build();
                m = factory13.buildHello()
                        .setXid(2000)
                        .setElements(Collections.singletonList(hem))
                        .build();
            } else {
                m = factory10.buildHello()
                    .setXid(2000)
                    .build();
            }
            break;
        case FEATURES_REQUEST:
            m = factory.buildFeaturesRequest()
            .setXid(2000)
            .build();
            break;
        case FEATURES_REPLY:

            m = factory.buildFeaturesReply()
            .setDatapathId(DatapathId.of(1000L))
            .setXid(2000)
            .build();
            break;
        case SET_CONFIG:
            m = factory.buildSetConfig()
            .setMissSendLen((short) 0xffff)
            .setXid(2000)
            .build();
            break;
        case BARRIER_REQUEST:
            m = factory.buildBarrierRequest()
            .setXid(2000)
            .build();
            break;
        case GET_CONFIG_REQUEST:
            m = factory.buildGetConfigRequest()
            .setXid(2000)
            .build();
            break;
        case GET_CONFIG_REPLY:
            m = factory.buildGetConfigReply()
            .setMissSendLen((short)0xffff)
            .setXid(2000)
            .build();
            break;
        case STATS_REQUEST:
            break;
        case STATS_REPLY:
            m = factory.buildDescStatsReply()
            .setDpDesc("Datapath Description")
            .setHwDesc("Hardware Secription")
            .setMfrDesc("Manufacturer Desctiption")
            .setSerialNum("Serial Number")
            .setSwDesc("Software Desription")
            .build();
            break;
        case ECHO_REQUEST:
            m = factory.buildEchoRequest()
            .setXid(2000)
            .build();
            break;
        case FLOW_REMOVED:
            break;

        case PACKET_IN:
            m = factory.buildPacketIn()
            .setReason(OFPacketInReason.NO_MATCH)
            .setTotalLen(1500)
            .setXid(2000)
            .build();
            break;
        case PORT_STATUS:
            m = factory.buildPortStatus()
            .setXid(2000)
            .build();
            break;

        default:
            m = factory.buildFeaturesRequest()
            .setXid(2000)
            .build();
            break;
        }

        return (m);
    }
}