Merge "Barrier turn on/off-add switcher value to Config-Subsystem" into stable/lithium

[openflowjava.git] / openflow-protocol-impl / src / test / java / org / opendaylight / openflowjava / protocol / impl / core / connection / SwitchConnectionProviderImpl02Test.java

diff --git a/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/core/connection/SwitchConnectionProviderImpl02Test.java b/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/core/connection/SwitchConnectionProviderImpl02Test.java
index c83e60c5383f7334e8cc4ad53352fc1eb22c8566..78b243256ca0f57299c02ed898b7930a4dc2c92e 100644 (file)
--- a/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/core/connection/SwitchConnectionProviderImpl02Test.java
+++ b/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/core/connection/SwitchConnectionProviderImpl02Test.java
@@ -7,9 +7,9 @@
  */
 package org.opendaylight.openflowjava.protocol.impl.core.connection;
 
+import com.google.common.util.concurrent.ListenableFuture;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
-
 import org.junit.Assert;
 import org.junit.Test;
 import org.mockito.Mock;
@@ -48,8 +48,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.queue.property.header.QueueProperty;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.table.features.properties.grouping.TableFeatureProperties;
 
-import com.google.common.util.concurrent.ListenableFuture;
-
 /**
  * @author madamjak
  * @author michal.polkorab
@@ -76,7 +74,7 @@ public class SwitchConnectionProviderImpl02Test {
      * Creates new {@link SwitchConnectionProvider} instance for each test
      * @param protocol communication protocol
      */
-    public void startUp(TransportProtocol protocol) {
+    public void startUp(final TransportProtocol protocol) {
         MockitoAnnotations.initMocks(this);
         config = null;
         if (protocol != null) {
@@ -85,10 +83,10 @@ public class SwitchConnectionProviderImpl02Test {
         provider = new SwitchConnectionProviderImpl();
     }
 
-    private void createConfig(TransportProtocol protocol) {
+    private void createConfig(final TransportProtocol protocol) {
         try {
             startupAddress = InetAddress.getLocalHost();
-        } catch (UnknownHostException e) {
+        } catch (final UnknownHostException e) {
             e.printStackTrace();
         }
         tlsConfiguration = null;
@@ -97,7 +95,7 @@ public class SwitchConnectionProviderImpl02Test {
                     "/selfSignedSwitch", PathType.CLASSPATH, KeystoreType.JKS,
                     "/selfSignedController", PathType.CLASSPATH) ;
         }
-        config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT);
+        config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true);
         config.setTransferProtocol(protocol);
     }
 
@@ -109,8 +107,8 @@ public class SwitchConnectionProviderImpl02Test {
     public void testServerFacade(){
         startUp(TransportProtocol.TCP);
         provider.setConfiguration(config);
-        ListenableFuture<Boolean> future = provider.startup();
-        ServerFacade serverFacade = provider.getServerFacade();
+        final ListenableFuture<Boolean> future = provider.startup();
+        final ServerFacade serverFacade = provider.getServerFacade();
         Assert.assertNotNull("Wrong -- getServerFacade return null",serverFacade);
     }
 
@@ -129,10 +127,10 @@ public class SwitchConnectionProviderImpl02Test {
     public void testUnregisterWrongKeys(){
         startUp(TransportProtocol.TCP);
         provider.setConfiguration(config);
-        ExperimenterInstructionSerializerKey testSerKey
+        final ExperimenterInstructionSerializerKey testSerKey
             = new ExperimenterInstructionSerializerKey(EncodeConstants.OF10_VERSION_ID,42L);
         Assert.assertFalse("Wrong -- unregisterSerializer",provider.unregisterSerializer(testSerKey));
-        ExperimenterInstructionDeserializerKey tesDeserKey
+        final ExperimenterInstructionDeserializerKey tesDeserKey
             = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF10_VERSION_ID,24L);
         Assert.assertFalse("Wrong -- unregisterDeserializer",provider.unregisterDeserializer(tesDeserKey));
     }
@@ -145,97 +143,97 @@ public class SwitchConnectionProviderImpl02Test {
         startUp(TransportProtocol.TCP);
         provider.setConfiguration(config);
         // -- registerActionSerializer
-        ExperimenterActionSerializerKey key1
+        final ExperimenterActionSerializerKey key1
             = new ExperimenterActionSerializerKey(EncodeConstants.OF10_VERSION_ID, 42L, TestSubType.class);
         provider.registerActionSerializer(key1, serializer);
         Assert.assertTrue("Wrong -- unregister ActionSerializer", provider.unregisterSerializer(key1));
         Assert.assertFalse("Wrong -- unregister ActionSerializer by not existing key", provider.unregisterSerializer(key1));
         // -- registerActionDeserializer
-        ExperimenterActionDeserializerKey key2
+        final ExperimenterActionDeserializerKey key2
             = new ExperimenterActionDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L);
         provider.registerActionDeserializer(key2, deserializer);
         Assert.assertTrue("Wrong -- unregister ActionDeserializer", provider.unregisterDeserializer(key2));
         Assert.assertFalse("Wrong -- unregister ActionDeserializer by not existing key", provider.unregisterDeserializer(key2));
         // -- registerInstructionSerializer
-        ExperimenterInstructionSerializerKey key3
+        final ExperimenterInstructionSerializerKey key3
             = new ExperimenterInstructionSerializerKey(EncodeConstants.OF10_VERSION_ID,42L);
         provider.registerInstructionSerializer(key3, serializer);
         Assert.assertTrue("Wrong -- unregister InstructionSerializer", provider.unregisterSerializer(key3));
         Assert.assertFalse("Wrong -- unregister InstructionSerializer by not existing key", provider.unregisterSerializer(key3));
         // -- registerInstructionDeserializer
-        ExperimenterInstructionDeserializerKey key4
+        final ExperimenterInstructionDeserializerKey key4
             = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF10_VERSION_ID,42L);
         provider.registerInstructionDeserializer(key4, deserializer);
         Assert.assertTrue("Wrong -- unregister InstructionDeserializer", provider.unregisterDeserializer(key4));
         Assert.assertFalse("Wrong -- unregister InstructionDeserializer by not existing key", provider.unregisterDeserializer(key4));
         // -- registerMatchEntryDeserializer
-        MatchEntryDeserializerKey key5
+        final MatchEntryDeserializerKey key5
             = new MatchEntryDeserializerKey(EncodeConstants.OF10_VERSION_ID, 0x8000, 42);
         provider.registerMatchEntryDeserializer(key5, deserializer);
         Assert.assertTrue("Wrong -- unregister MatchEntryDeserializer", provider.unregisterDeserializer(key5));
         Assert.assertFalse("Wrong -- unregister MatchEntryDeserializer by not existing key", provider.unregisterDeserializer(key5));
         // -- registerErrorDeserializer
-        ExperimenterIdDeserializerKey key6
+        final ExperimenterIdDeserializerKey key6
             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, ErrorMessage.class);
         provider.registerErrorDeserializer(key6, deserializerError);
         Assert.assertTrue("Wrong -- unregister ErrorDeserializer", provider.unregisterDeserializer(key6));
         Assert.assertFalse("Wrong -- unregister ErrorDeserializer by not existing key", provider.unregisterDeserializer(key6));
         // -- registerExperimenterMessageDeserializer
-        ExperimenterIdDeserializerKey key7
+        final ExperimenterIdDeserializerKey key7
             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, ExperimenterMessage.class);
         provider.registerExperimenterMessageDeserializer(key7, deserializerExpMsg);
         Assert.assertTrue("Wrong -- unregister ExperimenterMessageDeserializer", provider.unregisterDeserializer(key7));
         Assert.assertFalse("Wrong -- unregister ExperimenterMessageDeserializer by not existing key", provider.unregisterDeserializer(key7));
         // -- registerMultipartReplyMessageDeserializer
-        ExperimenterIdDeserializerKey key8
+        final ExperimenterIdDeserializerKey key8
             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MultipartReplyMessage.class);
         provider.registerMultipartReplyMessageDeserializer(key8, deserializerMultipartRplMsg);
         Assert.assertTrue("Wrong -- unregister MultipartReplyMessageDeserializer", provider.unregisterDeserializer(key8));
         Assert.assertFalse("Wrong -- unregister MultipartReplyMessageDeserializer by not existing key", provider.unregisterDeserializer(key8));
         // -- registerMultipartReplyTFDeserializer
-        ExperimenterIdDeserializerKey key9 =
+        final ExperimenterIdDeserializerKey key9 =
                 new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MultipartReplyMessage.class);
         provider.registerMultipartReplyTFDeserializer(key9, deserializer);
         Assert.assertTrue("Wrong -- unregister MultipartReplyTFDeserializer", provider.unregisterDeserializer(key9));
         Assert.assertFalse("Wrong -- unregister MultipartReplyTFDeserializer by non existing key", provider.unregisterDeserializer(key9));
         // -- registerQueuePropertyDeserializer
-        ExperimenterIdDeserializerKey key10
+        final ExperimenterIdDeserializerKey key10
             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, QueueProperty.class);
         provider.registerQueuePropertyDeserializer(key10, deserializerQueueProperty);
         Assert.assertTrue("Wrong -- unregister QueuePropertyDeserializer", provider.unregisterDeserializer(key10));
         Assert.assertFalse("Wrong -- unregister QueuePropertyDeserializer by not existing key", provider.unregisterDeserializer(key10));
         // -- registerMeterBandDeserializer
-        ExperimenterIdDeserializerKey key11
+        final ExperimenterIdDeserializerKey key11
             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MeterBandExperimenterCase.class);
         provider.registerMeterBandDeserializer(key11, deserializerMeterBandExpCase);
         Assert.assertTrue("Wrong -- unregister MeterBandDeserializer", provider.unregisterDeserializer(key11));
         Assert.assertFalse("Wrong -- unregister MeterBandDeserializer by not existing key", provider.unregisterDeserializer(key11));
         // -- registerExperimenterMessageSerializer
-        ExperimenterIdSerializerKey<ExperimenterInput> key12
+        final ExperimenterIdSerializerKey<ExperimenterInput> key12
             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,ExperimenterInput.class);
         provider.registerExperimenterMessageSerializer(key12, serializerExperimenterInput);
         Assert.assertTrue("Wrong -- unregister ExperimenterMessageSerializer", provider.unregisterSerializer(key12));
         Assert.assertFalse("Wrong -- unregister ExperimenterMessageSerializer by not existing key", provider.unregisterSerializer(key12));
         //registerMultipartRequestSerializer
-        ExperimenterIdSerializerKey<MultipartRequestExperimenterCase> key13
+        final ExperimenterIdSerializerKey<MultipartRequestExperimenterCase> key13
             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,MultipartRequestExperimenterCase.class);
         provider.registerMultipartRequestSerializer(key13, serializerMultipartRequestExpCase);
         Assert.assertTrue("Wrong -- unregister MultipartRequestSerializer", provider.unregisterSerializer(key13));
         Assert.assertFalse("Wrong -- unregister MultipartRequestSerializer by not existing key", provider.unregisterSerializer(key13));
         // -- registerMultipartRequestTFSerializer
-        ExperimenterIdSerializerKey<TableFeatureProperties> key14
+        final ExperimenterIdSerializerKey<TableFeatureProperties> key14
             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,TableFeatureProperties.class);
         provider.registerMultipartRequestTFSerializer(key14, serializer);
         Assert.assertTrue("Wrong -- unregister MultipartRequestTFSerializer", provider.unregisterSerializer(key14));
         Assert.assertFalse("Wrong -- unregister MultipartRequestTFSerializer by not existing key", provider.unregisterSerializer(key14));
         // -- registerMeterBandSerializer
-        ExperimenterIdSerializerKey<MeterBandExperimenterCase> key15
+        final ExperimenterIdSerializerKey<MeterBandExperimenterCase> key15
             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,MeterBandExperimenterCase.class);
         provider.registerMeterBandSerializer(key15, serializerMeterBandExpCase);
         Assert.assertTrue("Wrong -- unregister MeterBandSerializer", provider.unregisterSerializer(key15));
         Assert.assertFalse("Wrong -- unregister MeterBandSerializer by not existing key", provider.unregisterSerializer(key15));
         // -- registerMatchEntrySerializer
-        MatchEntrySerializerKey<OpenflowBasicClass, InPort> key16
+        final MatchEntrySerializerKey<OpenflowBasicClass, InPort> key16
             = new MatchEntrySerializerKey<>(EncodeConstants.OF13_VERSION_ID, OpenflowBasicClass.class, InPort.class);
         provider.registerMatchEntrySerializer(key16, serializer);
         Assert.assertTrue("Wrong -- unregister MatchEntrySerializer", provider.unregisterSerializer(key16));