openflowplugin/src/test/java/org/opendaylight/openflowplugin/openflow/md/core/session/MessageDispatchServiceImplTest.java

   1 /**
   2  * Copyright IBM Corporation, 2013.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.openflowplugin.openflow.md.core.session;
   9
  10 import java.math.BigInteger;
  11 import java.net.InetSocketAddress;
  12 import java.util.HashMap;
  13 import java.util.Iterator;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Map.Entry;
  17 import java.util.Set;
  18 import java.util.concurrent.Future;
  19 import org.junit.Assert;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
  23 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionReadyListener;
  24 import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandler;
  25 import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandlerRegistration;
  26 import org.opendaylight.openflowplugin.api.OFConstants;
  27 import org.opendaylight.openflowplugin.api.openflow.md.ModelDrivenSwitch;
  28 import org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor;
  29 import org.opendaylight.openflowplugin.api.openflow.md.core.ErrorHandler;
  30 import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationEnqueuer;
  31 import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationQueueWrapper;
  32 import org.opendaylight.openflowplugin.api.openflow.md.core.SwitchConnectionDistinguisher;
  33 import org.opendaylight.openflowplugin.api.openflow.md.core.session.IMessageDispatchService;
  34 import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionContext;
  35 import org.opendaylight.openflowplugin.api.openflow.md.core.session.SwitchSessionKeyOF;
  36 import org.opendaylight.openflowplugin.api.openflow.md.queue.QueueProcessor;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.ControllerRole;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInput;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInputBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierOutput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoInput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoOutput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoReplyInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInput;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInputBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowModInput;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncInput;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncInputBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncOutput;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetConfigInput;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetConfigInputBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetConfigOutput;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesInput;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesInputBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetQueueConfigInput;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetQueueConfigInputBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetQueueConfigOutput;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GroupModInput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.HelloInput;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MeterModInput;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInput;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInputBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OpenflowProtocolListener;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketOutInput;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketOutInputBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortModInput;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.RoleRequestInput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.RoleRequestInputBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.RoleRequestOutput;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetAsyncInput;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetConfigInput;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.TableModInput;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.TableModInputBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.system.rev130927.SystemNotificationsListener;
  78 import org.opendaylight.yangtools.concepts.CompositeObjectRegistration;
  79 import org.opendaylight.yangtools.yang.binding.DataObject;
  80 import org.opendaylight.yangtools.yang.common.RpcError;
  81 import org.opendaylight.yangtools.yang.common.RpcResult;
  82
  83 /**
  84  * test for {@link MessageDispatchServiceImpl}
  85  */
  86 public class MessageDispatchServiceImplTest {
  87
  88     MockSessionContext session;
  89
  90     /**
  91      * @throws java.lang.Exception
  92      */
  93     @Before
  94     public void setUp() throws Exception {
  95         session = new MockSessionContext(0);
  96
  97     }
  98
  99     /**
 100      * Test barrier message for null cookie
 101      *
 102      * @throws Exception
 103      */
 104     @Test
 105     public void testBarrierMessageForPrimary() throws Exception {
 106         MockConnectionConductor conductor = new MockConnectionConductor(1);
 107         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 108         BarrierInputBuilder barrierMsg = new BarrierInputBuilder();
 109         session.getMessageDispatchService().barrier(barrierMsg.build(), cookie);
 110         Assert.assertEquals(MessageType.BARRIER, session.getPrimaryConductor()
 111                 .getMessageType());
 112     }
 113
 114     /**
 115      * Test experimenter message for null cookie
 116      */
 117     @Test
 118     public void testExperimenter() {
 119         MockConnectionConductor conductor = new MockConnectionConductor(1);
 120         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 121         ExperimenterInputBuilder experimenterInputBuilder = new ExperimenterInputBuilder();
 122         session.getMessageDispatchService().experimenter(
 123                 experimenterInputBuilder.build(), cookie);
 124         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 125                 .getMessageType());
 126     }
 127
 128     /**
 129      * Test get async input with null cookie
 130      */
 131     @Test
 132     public void testGetAsync() {
 133         MockConnectionConductor conductor = new MockConnectionConductor(1);
 134         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 135         GetAsyncInputBuilder getAsyncInputBuilder = new GetAsyncInputBuilder();
 136         session.getMessageDispatchService().getAsync(
 137                 getAsyncInputBuilder.build(), cookie);
 138         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 139                 .getMessageType());
 140     }
 141
 142     /**
 143      * Test get async output with null cookie
 144      */
 145     @Test
 146     public void testGetConfig() {
 147         MockConnectionConductor conductor = new MockConnectionConductor(1);
 148         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 149         GetConfigInputBuilder getConfigInputBuilder = new GetConfigInputBuilder();
 150         session.getMessageDispatchService().getConfig(
 151                 getConfigInputBuilder.build(), cookie);
 152         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 153                 .getMessageType());
 154     }
 155
 156     /**
 157      * Test get features with null cookie
 158      */
 159     @Test
 160     public void testGetFeatures() {
 161         MockConnectionConductor conductor = new MockConnectionConductor(1);
 162         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 163         GetFeaturesInputBuilder getFeaturesInputBuilder = new GetFeaturesInputBuilder();
 164         session.getMessageDispatchService().getFeatures(
 165                 getFeaturesInputBuilder.build(), cookie);
 166         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 167                 .getMessageType());
 168     }
 169
 170     /**
 171      * Test get queue config with null cookie
 172      */
 173     @Test
 174     public void testGetQueueConfig() {
 175         MockConnectionConductor conductor = new MockConnectionConductor(1);
 176         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 177         GetQueueConfigInputBuilder getQueueConfigInputBuilder = new GetQueueConfigInputBuilder();
 178         session.getMessageDispatchService().getQueueConfig(
 179                 getQueueConfigInputBuilder.build(), cookie);
 180         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 181                 .getMessageType());
 182     }
 183
 184     /**
 185      * Test multipart request with null cookie
 186      */
 187     @Test
 188     public void testGetMultipart() {
 189         MockConnectionConductor conductor = new MockConnectionConductor(1);
 190         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 191         MultipartRequestInputBuilder multipartRequestInputBuilder = new MultipartRequestInputBuilder();
 192         session.getMessageDispatchService().multipartRequest(
 193                 multipartRequestInputBuilder.build(), cookie);
 194         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 195                 .getMessageType());
 196     }
 197
 198     /**
 199      * Test role request with null cookie
 200      */
 201     @Test
 202     public void testRoleRequest() {
 203         MockConnectionConductor conductor = new MockConnectionConductor(1);
 204         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 205         RoleRequestInputBuilder roleRequestInputBuilder = new RoleRequestInputBuilder();
 206         session.getMessageDispatchService().roleRequest(
 207                 roleRequestInputBuilder.build(), cookie);
 208         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 209                 .getMessageType());
 210     }
 211
 212     /**
 213      * Test table mod with null cookie
 214      */
 215     @Test
 216     public void testTableMod() {
 217         MockConnectionConductor conductor = new MockConnectionConductor(1);
 218         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 219         TableModInputBuilder tableModInputBuilder = new TableModInputBuilder();
 220         session.getMessageDispatchService().tableMod(
 221                 tableModInputBuilder.build(), cookie);
 222         Assert.assertEquals(MessageType.TABLEMOD, session.getPrimaryConductor()
 223                 .getMessageType());
 224     }
 225
 226     /**
 227      * Test packet out message for primary connection
 228      *
 229      * @throws Exception
 230      */
 231     @Test
 232     public void testPacketOutMessageForPrimary() throws Exception {
 233         session.getMessageDispatchService().packetOut(null, null);
 234         Assert.assertEquals(MessageType.PACKETOUT, session
 235                 .getPrimaryConductor().getMessageType());
 236     }
 237
 238     /**
 239      * Test packet out message for auxiliary connection
 240      *
 241      * @throws Exception
 242      */
 243     @Test
 244     public void testPacketOutMessageForAuxiliary() throws Exception {
 245         MockConnectionConductor conductor = new MockConnectionConductor(1);
 246         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 247         session.addAuxiliaryConductor(cookie, conductor);
 248         session.getMessageDispatchService().packetOut(null, cookie);
 249         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 250                 .getMessageType());
 251         conductor = (MockConnectionConductor) session
 252                 .getAuxiliaryConductor(cookie);
 253         Assert.assertEquals(MessageType.PACKETOUT, conductor.getMessageType());
 254     }
 255
 256     /**
 257      * Test packet out message when multiple auxiliary connection exist
 258      *
 259      * @throws Exception
 260      */
 261     @Test
 262     public void testPacketOutMessageForMultipleAuxiliary() throws Exception {
 263         MockConnectionConductor conductor1 = new MockConnectionConductor(1);
 264         SwitchConnectionDistinguisher cookie1 = conductor1.getAuxiliaryKey();
 265         session.addAuxiliaryConductor(cookie1, conductor1);
 266         MockConnectionConductor conductor2 = new MockConnectionConductor(2);
 267         SwitchConnectionDistinguisher cookie2 = conductor2.getAuxiliaryKey();
 268         session.addAuxiliaryConductor(cookie2, conductor2);
 269         MockConnectionConductor conductor3 = new MockConnectionConductor(3);
 270         SwitchConnectionDistinguisher cookie3 = conductor3.getAuxiliaryKey();
 271         session.addAuxiliaryConductor(cookie3, conductor3);
 272         PacketOutInputBuilder builder = new PacketOutInputBuilder();
 273         // send message
 274         session.getMessageDispatchService().packetOut(builder.build(), cookie2);
 275
 276         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor()
 277                 .getMessageType());
 278
 279         conductor3 = (MockConnectionConductor) session
 280                 .getAuxiliaryConductor(cookie3);
 281         Assert.assertEquals(MessageType.NONE, conductor3.getMessageType());
 282
 283         conductor2 = (MockConnectionConductor) session
 284                 .getAuxiliaryConductor(cookie2);
 285         Assert.assertEquals(MessageType.PACKETOUT, conductor2.getMessageType());
 286
 287         conductor1 = (MockConnectionConductor) session
 288                 .getAuxiliaryConductor(cookie1);
 289         Assert.assertEquals(MessageType.NONE, conductor1.getMessageType());
 290
 291     }
 292
 293     /**
 294      * Test for invalid session
 295      *
 296      * @throws Exception
 297      */
 298     @Test
 299     public void testInvalidSession() throws Exception {
 300         session.setValid(false);
 301         Future<RpcResult<Void>> resultFuture = session
 302                 .getMessageDispatchService().packetOut(null, null);
 303         if (resultFuture.isDone()) {
 304             RpcResult<Void> rpcResult = resultFuture.get();
 305             Assert.assertTrue(!rpcResult.getErrors().isEmpty());
 306
 307             Iterator<RpcError> it = rpcResult.getErrors().iterator();
 308             RpcError rpcError = it.next();
 309
 310             Assert.assertTrue(rpcError.getApplicationTag().equals(
 311                     OFConstants.APPLICATION_TAG));
 312             Assert.assertTrue(rpcError.getTag().equals(
 313                     OFConstants.ERROR_TAG_TIMEOUT));
 314             Assert.assertTrue(rpcError.getErrorType().equals(
 315                     RpcError.ErrorType.TRANSPORT));
 316         }
 317     }
 318
 319 }
 320
 321 class MockSessionContext implements SessionContext {
 322     private MockConnectionConductor conductor;
 323     private Map<SwitchConnectionDistinguisher, ConnectionConductor> map;
 324     private IMessageDispatchService messageService;
 325     private boolean isValid = true;
 326     private CompositeObjectRegistration<ModelDrivenSwitch> registration;
 327     private int seed;
 328     private SwitchSessionKeyOF sessionKey;
 329
 330     MockSessionContext(int conductorNum) {
 331         conductor = new MockConnectionConductor(conductorNum);
 332         map = new HashMap<>();
 333         messageService = new MessageDispatchServiceImpl(this);
 334         sessionKey = new SwitchSessionKeyOF();
 335         sessionKey.setDatapathId(new BigInteger("0"));
 336     }
 337
 338     @Override
 339     public MockConnectionConductor getPrimaryConductor() {
 340         // TODO Auto-generated method stub
 341         return conductor;
 342     }
 343
 344     @Override
 345     public GetFeaturesOutput getFeatures() {
 346         // TODO Auto-generated method stub
 347         return null;
 348     }
 349
 350     @Override
 351     public ConnectionConductor getAuxiliaryConductor(
 352             SwitchConnectionDistinguisher auxiliaryKey) {
 353
 354         return map.get(auxiliaryKey);
 355     }
 356
 357     @Override
 358     public Set<Entry<SwitchConnectionDistinguisher, ConnectionConductor>> getAuxiliaryConductors() {
 359         // TODO Auto-generated method stub
 360         return null;
 361     }
 362
 363     @Override
 364     public void addAuxiliaryConductor(
 365             SwitchConnectionDistinguisher auxiliaryKey,
 366             ConnectionConductor conductorArg) {
 367         map.put(auxiliaryKey, conductorArg);
 368     }
 369
 370     @Override
 371     public ConnectionConductor removeAuxiliaryConductor(
 372             SwitchConnectionDistinguisher connectionCookie) {
 373         return map.remove(connectionCookie);
 374     }
 375
 376     @Override
 377     public boolean isValid() {
 378         // TODO Auto-generated method stub
 379         return isValid;
 380     }
 381
 382     @Override
 383     public void setValid(boolean valid) {
 384         isValid = valid;
 385     }
 386
 387     @Override
 388     public SwitchSessionKeyOF getSessionKey() {
 389         return sessionKey;
 390     }
 391
 392     @Override
 393     public IMessageDispatchService getMessageDispatchService() {
 394         // TODO Auto-generated method stub
 395         return messageService;
 396     }
 397
 398     @Override
 399     public Long getNextXid() {
 400         // TODO Auto-generated method stub
 401         return null;
 402     }
 403
 404     @Override
 405     public Map<Long, PortGrouping> getPhysicalPorts() {
 406         // TODO Auto-generated method stub
 407         return null;
 408     }
 409
 410     @Override
 411     public Set<Long> getPorts() {
 412         // TODO Auto-generated method stub
 413         return null;
 414     }
 415
 416     @Override
 417     public PortGrouping getPhysicalPort(Long portNumber) {
 418         // TODO Auto-generated method stub
 419         return null;
 420     }
 421
 422     @Override
 423     public Boolean getPortBandwidth(Long portNumber) {
 424         // TODO Auto-generated method stub
 425         return null;
 426     }
 427
 428     @Override
 429     public boolean isPortEnabled(long portNumber) {
 430         // TODO Auto-generated method stub
 431         return false;
 432     }
 433
 434     @Override
 435     public boolean isPortEnabled(PortGrouping port) {
 436         // TODO Auto-generated method stub
 437         return false;
 438     }
 439
 440     @Override
 441     public List<PortGrouping> getEnabledPorts() {
 442         // TODO Auto-generated method stub
 443         return null;
 444     }
 445
 446     @Override
 447     public Map<Long, Boolean> getPortsBandwidth() {
 448         // TODO Auto-generated method stub
 449         return null;
 450     }
 451
 452     @Override
 453     public CompositeObjectRegistration<ModelDrivenSwitch> getProviderRegistration() {
 454         return registration;
 455     }
 456
 457     @Override
 458     public void setProviderRegistration(
 459             CompositeObjectRegistration<ModelDrivenSwitch> registration) {
 460         this.registration = registration;
 461     }
 462
 463     @Override
 464     public int getSeed() {
 465         return seed;
 466     }
 467
 468     /**
 469      * @param seed
 470      *            the seed to set
 471      */
 472     public void setSeed(int seed) {
 473         this.seed = seed;
 474     }
 475
 476     @Override
 477     public NotificationEnqueuer getNotificationEnqueuer() {
 478         return conductor;
 479     }
 480
 481     @Override
 482     public ControllerRole getRoleOnDevice() {
 483         return null;
 484     }
 485
 486     @Override
 487     public void setRoleOnDevice(ControllerRole roleOnDevice) {
 488         // NOOP
 489     }
 490 }
 491
 492 class MockConnectionConductor implements ConnectionConductor,
 493         NotificationEnqueuer {
 494
 495     private int conductorNum;
 496     private MockConnectionAdapter adapter;
 497
 498     public MockConnectionConductor(int conductorNumber) {
 499         conductorNum = conductorNumber;
 500         adapter = new MockConnectionAdapter();
 501     }
 502
 503     @Override
 504     public void init() {
 505         // TODO Auto-generated method stub
 506
 507     }
 508
 509     @Override
 510     public Short getVersion() {
 511         // TODO Auto-generated method stub
 512         return null;
 513     }
 514
 515     @Override
 516     public CONDUCTOR_STATE getConductorState() {
 517         // TODO Auto-generated method stub
 518         return null;
 519     }
 520
 521     @Override
 522     public void setConductorState(CONDUCTOR_STATE conductorState) {
 523         // TODO Auto-generated method stub
 524
 525     }
 526
 527     @Override
 528     public Future<Boolean> disconnect() {
 529         // TODO Auto-generated method stub
 530         return null;
 531     }
 532
 533     @Override
 534     public void setSessionContext(SessionContext context) {
 535         // TODO Auto-generated method stub
 536
 537     }
 538
 539     @Override
 540     public void setConnectionCookie(SwitchConnectionDistinguisher auxiliaryKey) {
 541         // TODO Auto-generated method stub
 542
 543     }
 544
 545     @Override
 546     public SessionContext getSessionContext() {
 547         // TODO Auto-generated method stub
 548         return null;
 549     }
 550
 551     @Override
 552     public SwitchConnectionDistinguisher getAuxiliaryKey() {
 553         if (0 != conductorNum) {
 554             SwitchConnectionCookieOFImpl key = new SwitchConnectionCookieOFImpl();
 555             key.setAuxiliaryId((short) conductorNum);
 556             key.init(42);
 557             return key;
 558         }
 559         return null;
 560     }
 561
 562     @Override
 563     public ConnectionAdapter getConnectionAdapter() {
 564         // TODO Auto-generated method stub
 565         return adapter;
 566     }
 567
 568     public MessageType getMessageType() {
 569         return adapter.getMessageType();
 570     }
 571
 572     @Override
 573     public void setQueueProcessor(
 574             QueueProcessor<OfHeader, DataObject> queueKeeper) {
 575         // NOOP
 576     }
 577
 578     @Override
 579     public void setErrorHandler(ErrorHandler errorHandler) {
 580         // NOOP
 581     }
 582
 583     @Override
 584     public void setId(int conductorId) {
 585         // NOOP
 586     }
 587
 588     @Override
 589     public void enqueueNotification(NotificationQueueWrapper notification) {
 590         // NOOP
 591     }
 592 }
 593
 594 enum MessageType {
 595     NONE, BARRIER, FLOWMOD, TABLEMOD, PACKETOUT;
 596 }
 597
 598 class MockConnectionAdapter implements ConnectionAdapter {
 599
 600     private MessageType messageType;
 601     private ConnectionReadyListener connectionReadyListener;
 602     private boolean packetInFiltering;
 603
 604     public MockConnectionAdapter() {
 605         setMessageType(MessageType.NONE);
 606     }
 607
 608     @Override
 609     public Future<RpcResult<BarrierOutput>> barrier(BarrierInput input) {
 610         setMessageType(MessageType.BARRIER);
 611         return null;
 612     }
 613
 614     @Override
 615     public Future<RpcResult<EchoOutput>> echo(EchoInput input) {
 616         // TODO Auto-generated method stub
 617         return null;
 618     }
 619
 620     @Override
 621     public Future<RpcResult<Void>> echoReply(EchoReplyInput input) {
 622         // TODO Auto-generated method stub
 623         return null;
 624     }
 625
 626     @Override
 627     public Future<RpcResult<Void>> experimenter(ExperimenterInput input) {
 628         // TODO Auto-generated method stub
 629         return null;
 630     }
 631
 632     @Override
 633     public Future<RpcResult<Void>> flowMod(FlowModInput input) {
 634         setMessageType(MessageType.FLOWMOD);
 635         return null;
 636     }
 637
 638     @Override
 639     public Future<RpcResult<GetAsyncOutput>> getAsync(GetAsyncInput input) {
 640         // TODO Auto-generated method stub
 641         return null;
 642     }
 643
 644     @Override
 645     public Future<RpcResult<GetConfigOutput>> getConfig(GetConfigInput input) {
 646         // TODO Auto-generated method stub
 647         return null;
 648     }
 649
 650     @Override
 651     public Future<RpcResult<GetFeaturesOutput>> getFeatures(
 652             GetFeaturesInput input) {
 653         // TODO Auto-generated method stub
 654         return null;
 655     }
 656
 657     @Override
 658     public Future<RpcResult<GetQueueConfigOutput>> getQueueConfig(
 659             GetQueueConfigInput input) {
 660         // TODO Auto-generated method stub
 661         return null;
 662     }
 663
 664     @Override
 665     public Future<RpcResult<Void>> groupMod(GroupModInput input) {
 666         // TODO Auto-generated method stub
 667         return null;
 668     }
 669
 670     @Override
 671     public Future<RpcResult<Void>> hello(HelloInput input) {
 672         // TODO Auto-generated method stub
 673         return null;
 674     }
 675
 676     @Override
 677     public Future<RpcResult<Void>> meterMod(MeterModInput input) {
 678         // TODO Auto-generated method stub
 679         return null;
 680     }
 681
 682     @Override
 683     public Future<RpcResult<Void>> packetOut(PacketOutInput input) {
 684         setMessageType(MessageType.PACKETOUT);
 685         return null;
 686     }
 687
 688     @Override
 689     public Future<RpcResult<Void>> portMod(PortModInput input) {
 690         // TODO Auto-generated method stub
 691         return null;
 692     }
 693
 694     @Override
 695     public Future<RpcResult<RoleRequestOutput>> roleRequest(
 696             RoleRequestInput input) {
 697         // TODO Auto-generated method stub
 698         return null;
 699     }
 700
 701     @Override
 702     public Future<RpcResult<Void>> setAsync(SetAsyncInput input) {
 703         // TODO Auto-generated method stub
 704         return null;
 705     }
 706
 707     @Override
 708     public Future<RpcResult<Void>> setConfig(SetConfigInput input) {
 709         // TODO Auto-generated method stub
 710         return null;
 711     }
 712
 713     @Override
 714     public Future<RpcResult<Void>> tableMod(TableModInput input) {
 715         setMessageType(MessageType.TABLEMOD);
 716         return null;
 717     }
 718
 719     @Override
 720     public Future<Boolean> disconnect() {
 721         // TODO Auto-generated method stub
 722         return null;
 723     }
 724
 725     @Override
 726     public boolean isAlive() {
 727         // TODO Auto-generated method stub
 728         return false;
 729     }
 730
 731     @Override
 732     public void setMessageListener(OpenflowProtocolListener messageListener) {
 733         // TODO Auto-generated method stub
 734
 735     }
 736
 737     @Override
 738     public void setSystemListener(SystemNotificationsListener systemListener) {
 739         // TODO Auto-generated method stub
 740
 741     }
 742
 743     @Override
 744     public void checkListeners() {
 745         // TODO Auto-generated method stub
 746
 747     }
 748
 749     /**
 750      * @return the messageType
 751      */
 752     public MessageType getMessageType() {
 753         return messageType;
 754     }
 755
 756     /**
 757      * @param messageType
 758      *            the messageType to set
 759      */
 760     public void setMessageType(MessageType messageType) {
 761         this.messageType = messageType;
 762     }
 763
 764     @Override
 765     public void fireConnectionReadyNotification() {
 766         connectionReadyListener.onConnectionReady();
 767     }
 768
 769     @Override
 770     public void setConnectionReadyListener(
 771             ConnectionReadyListener connectionReadyListener) {
 772         this.connectionReadyListener = connectionReadyListener;
 773     }
 774
 775     @Override
 776     public Future<RpcResult<Void>> multipartRequest(MultipartRequestInput input) {
 777         // TODO Auto-generated method stub
 778         return null;
 779     }
 780
 781     /*
 782      * (non-Javadoc)
 783      *
 784      * @see
 785      * org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter
 786      * #getRemoteAddress()
 787      */
 788     @Override
 789     public InetSocketAddress getRemoteAddress() {
 790         // TODO Auto-generated method stub
 791         return null;
 792     }
 793
 794     @Override
 795     public boolean isAutoRead() {
 796         // TODO Auto-generated method stub
 797         return false;
 798     }
 799
 800     @Override
 801     public <T extends OutboundQueueHandler> OutboundQueueHandlerRegistration<T> registerOutboundQueueHandler(final T t, final int i, final long l) {
 802         return null;
 803     }
 804
 805     @Override
 806     public void setAutoRead(boolean arg0) {
 807         // TODO Auto-generated method stub
 808
 809     }
 810
 811     @Override
 812     public void setPacketInFiltering(boolean packetInFiltering) {
 813         this.packetInFiltering = packetInFiltering;
 814     }
 815 }