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