final org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId storedGroupId = new org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId(groupIdValue);
final KeyedInstanceIdentifier<Group, GroupKey> groupPath = dummyNodePath.augmentation(FlowCapableNode.class).child(Group.class, new GroupKey(storedGroupId));
- verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.any(InstanceIdentifier.class));
+ verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.<InstanceIdentifier<?>> any());
verify(deviceGroupRegistry).removeMarked();
verify(deviceGroupRegistry).store(storedGroupId);
verify(deviceContext).writeToTransaction(
final KeyedInstanceIdentifier<Flow, FlowKey> flowPath = dummyNodePath.augmentation(FlowCapableNode.class)
.child(Table.class, new TableKey((short) 0))
.child(Flow.class, new FlowKey(new FlowId("openflow:21")));
- verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.any(InstanceIdentifier.class));
+ verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.<InstanceIdentifier<?>>any());
verify(deviceFlowRegistry).storeIfNecessary(FlowRegistryKeyFactory.create(flowBld.build()), (short) 0);
verify(deviceContext).writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.eq(flowPath), Matchers.any(Flow.class));
}
new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(meterIdValue);
final KeyedInstanceIdentifier<Meter, MeterKey> meterPath = dummyNodePath.augmentation(FlowCapableNode.class)
.child(Meter.class, new MeterKey(meterId));
- verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.any(InstanceIdentifier.class));
+ verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.<InstanceIdentifier<?>>any());
verify(deviceMeterRegistry).store(meterId);
verify(deviceContext).writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.eq(meterPath), Matchers.any(Meter.class));
}
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
-
-import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
}
@Test
public void chainTableTrunkWriteOF10Test() {
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
- GetFeaturesOutput mockedFeatures = mock(GetFeaturesOutput.class);
+ final GetFeaturesOutput mockedFeatures = mock(GetFeaturesOutput.class);
when(mockedFeatures.getTables()).thenReturn((short) 2);
when(mockedDeviceState.getFeatures()).thenReturn(mockedFeatures);
when(mockedDeviceState.getNodeInstanceIdentifier()).thenReturn(DUMMY_NODE_II);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
- RpcResult<List<MultipartReply>> mockedRpcResult = mock(RpcResult.class);
+ final RpcResult<List<MultipartReply>> mockedRpcResult = mock(RpcResult.class);
when(mockedRpcResult.isSuccessful()).thenReturn(true);
- List<RpcResult<List<MultipartReply>>> data = new ArrayList<RpcResult<List<MultipartReply>>>();
+ final List<RpcResult<List<MultipartReply>>> data = new ArrayList<RpcResult<List<MultipartReply>>>();
data.add(mockedRpcResult);
data.add(mockedRpcResult);
DeviceInitializationUtils.chainTableTrunkWriteOF10(mockedDeviceContext, Futures.immediateFuture(data));
- verify(mockedDeviceContext, times(3))
- .writeToTransaction(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(FlowCapableNode.class));
+ verify(mockedDeviceContext, times(3)).writeToTransaction(any(LogicalDatastoreType.class),
+ Matchers.<InstanceIdentifier<FlowCapableNode>> any(), any(FlowCapableNode.class));
}
@Test
public void testTranslateAndWriteReplyTypeDesc() {
final ConnectionContext connectionContext = buildMockConnectionContext(OFConstants.OFP_VERSION_1_3);
Mockito.when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(connectionContext);
- DeviceState deviceState = Mockito.mock(DeviceState.class);
+ final DeviceState deviceState = Mockito.mock(DeviceState.class);
Mockito.when(mockedDeviceContext.getDeviceState()).thenReturn(deviceState);
- Collection<MultipartReply> multipartReplyMessages = prepareDataforTypeDesc(mockedDeviceContext);
+ final Collection<MultipartReply> multipartReplyMessages = prepareDataforTypeDesc(mockedDeviceContext);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPDESC, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
@Test
public void translateAndWriteReplyTypeTableFeatures() {
- TableFeaturesBuilder tableFeature = new TableFeaturesBuilder();
+ final TableFeaturesBuilder tableFeature = new TableFeaturesBuilder();
tableFeature.setTableId(DUMMY_TABLE_ID);
- List<TableFeatures> tableFeatures = new ArrayList<>();
+
final List<TableFeatures> tableFeatures = new ArrayList<>();
tableFeatures.add(tableFeature.build());
- MultipartReplyTableFeatures multipartReplyTableFeatures = new MultipartReplyTableFeaturesBuilder().setTableFeatures(tableFeatures).build();
- MultipartReplyTableFeaturesCaseBuilder multipartReplyTableFeaturesCaseBuilder = new MultipartReplyTableFeaturesCaseBuilder();
+ final MultipartReplyTableFeatures multipartReplyTableFeatures = new MultipartReplyTableFeaturesBuilder().setTableFeatures(tableFeatures).build();
+ final MultipartReplyTableFeaturesCaseBuilder multipartReplyTableFeaturesCaseBuilder = new MultipartReplyTableFeaturesCaseBuilder();
multipartReplyTableFeaturesCaseBuilder.setMultipartReplyTableFeatures(multipartReplyTableFeatures);
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyTableFeaturesCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyTableFeaturesCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPTABLEFEATURES, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
.writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL),
@Test
public void translateAndWriteReplyTypeMeterFeatures() {
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
- MultipartReplyMeterFeaturesBuilder multipartReplyMeterFeaturesBuilder = new MultipartReplyMeterFeaturesBuilder();
+ final MultipartReplyMeterFeaturesBuilder multipartReplyMeterFeaturesBuilder = new MultipartReplyMeterFeaturesBuilder();
multipartReplyMeterFeaturesBuilder.setBandTypes(new MeterBandTypeBitmap(true, true));
multipartReplyMeterFeaturesBuilder.setCapabilities(new MeterFlags(true, true, true, true));
multipartReplyMeterFeaturesBuilder.setMaxMeter(DUMMY_MAX_METER);
- MultipartReplyMeterFeaturesCaseBuilder multipartReplyMeterFeaturesCaseBuilder = new MultipartReplyMeterFeaturesCaseBuilder();
+ final MultipartReplyMeterFeaturesCaseBuilder multipartReplyMeterFeaturesCaseBuilder = new MultipartReplyMeterFeaturesCaseBuilder();
multipartReplyMeterFeaturesCaseBuilder.setMultipartReplyMeterFeatures(multipartReplyMeterFeaturesBuilder.build());
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyMeterFeaturesCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyMeterFeaturesCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPMETERFEATURES, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
.writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), eq(DUMMY_NODE_II.augmentation(NodeMeterFeatures.class)), any(NodeMeterFeatures.class));
@Test
public void translateAndWriteReplyTypeGroupFeatures() {
- MultipartReplyGroupFeaturesBuilder multipartReplyGroupFeaturesBuilder = new MultipartReplyGroupFeaturesBuilder();
+ final MultipartReplyGroupFeaturesBuilder multipartReplyGroupFeaturesBuilder = new MultipartReplyGroupFeaturesBuilder();
multipartReplyGroupFeaturesBuilder.setTypes(new GroupTypes(true, true, true, true));
multipartReplyGroupFeaturesBuilder.setCapabilities(new GroupCapabilities(true, true, true, true));
- ActionType actionType = new ActionType(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+ final ActionType actionType = new ActionType(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
multipartReplyGroupFeaturesBuilder.setActionsBitmap(Lists.newArrayList(actionType));
- MultipartReplyGroupFeatures multipartReplyGroupFeatures = multipartReplyGroupFeaturesBuilder.build();
+ final MultipartReplyGroupFeatures multipartReplyGroupFeatures = multipartReplyGroupFeaturesBuilder.build();
- MultipartReplyGroupFeaturesCaseBuilder multipartReplyGroupFeaturesCaseBuilder = new MultipartReplyGroupFeaturesCaseBuilder();
+ final MultipartReplyGroupFeaturesCaseBuilder multipartReplyGroupFeaturesCaseBuilder = new MultipartReplyGroupFeaturesCaseBuilder();
multipartReplyGroupFeaturesCaseBuilder.setMultipartReplyGroupFeatures(multipartReplyGroupFeatures);
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyGroupFeaturesCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyGroupFeaturesCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPGROUPFEATURES, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
@Test
public void translateAndWriteReplyTypePortDesc() {
- ConnectionContext mockedPrimaryConnectionContext = mock(ConnectionContext.class);
- FeaturesReply mockedFeatures = mock(FeaturesReply.class);
+ final ConnectionContext mockedPrimaryConnectionContext = mock(ConnectionContext.class);
+ final FeaturesReply mockedFeatures = mock(FeaturesReply.class);
when(mockedFeatures.getDatapathId()).thenReturn(new BigInteger(DUMMY_DATAPATH_ID));
when(mockedPrimaryConnectionContext.getFeatures()).thenReturn(mockedFeatures);
when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedPrimaryConnectionContext);
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
when(mockedDeviceState.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_0);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
- MessageTranslator mockedTranslator = mock(MessageTranslator.class);
+ final MessageTranslator mockedTranslator = mock(MessageTranslator.class);
when(translatorLibrary.lookupTranslator(any(TranslatorKey.class))).thenReturn(mockedTranslator);
when(mockedDeviceContext.oook()).thenReturn(translatorLibrary);
- MultipartReplyPortDescBuilder multipartReplyPortDescBuilder = new MultipartReplyPortDescBuilder();
+ final MultipartReplyPortDescBuilder multipartReplyPortDescBuilder = new MultipartReplyPortDescBuilder();
- PortsBuilder portsBuilder = new PortsBuilder();
+ final PortsBuilder portsBuilder = new PortsBuilder();
portsBuilder.setPortNo(DUMMY_PORT_NUMBER);
multipartReplyPortDescBuilder.setPorts(Lists.newArrayList(portsBuilder.build()));
- MultipartReplyPortDescCaseBuilder multipartReplyPortDescCaseBuilder = new MultipartReplyPortDescCaseBuilder();
+ final MultipartReplyPortDescCaseBuilder multipartReplyPortDescCaseBuilder = new MultipartReplyPortDescCaseBuilder();
multipartReplyPortDescCaseBuilder.setMultipartReplyPortDesc(multipartReplyPortDescBuilder.build());
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyPortDescCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyPortDescCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
OpenflowPortsUtil.init();
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPPORTDESC, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
- verify(mockedDeviceContext)
- .writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(NodeConnector.class));
+ verify(mockedDeviceContext).writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL),
+ Matchers.<InstanceIdentifier<NodeConnector>> any(), any(NodeConnector.class));
}
@Test
public void createSuccessProcessingCallbackTest() {
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
final ConnectionContext connectionContext = buildMockConnectionContext(OFConstants.OFP_VERSION_1_3);
- List<MultipartReply> multipartReplies = new ArrayList<>(prepareDataforTypeDesc(mockedDeviceContext));
- RpcResult<List<MultipartReply>> result = RpcResultBuilder.<List<MultipartReply>>success(multipartReplies).build();
+ final List<MultipartReply> multipartReplies = new ArrayList<>(prepareDataforTypeDesc(mockedDeviceContext));
+ final RpcResult<List<MultipartReply>> result = RpcResultBuilder.<List<MultipartReply>>success(multipartReplies).build();
ListenableFuture<RpcResult<List<MultipartReply>>> mockedRequestContextFuture = Futures.immediateFuture(result);
DeviceInitializationUtils.createSuccessProcessingCallback(MultipartType.OFPMPDESC, mockedDeviceContext, DUMMY_NODE_II, mockedRequestContextFuture);
verify(mockedDeviceContext).writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), eq(DUMMY_NODE_II.augmentation(FlowCapableNode.class)), any(FlowCapableNode.class));
- RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder.<List<MultipartReply>>failed().withError(RpcError.ErrorType.PROTOCOL, "dummy error").build();
+ final RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder.<List<MultipartReply>>failed().withError(RpcError.ErrorType.PROTOCOL, "dummy error").build();
mockedRequestContextFuture = Futures.immediateFuture(rpcResult);
DeviceInitializationUtils.createSuccessProcessingCallback(MultipartType.OFPMPDESC, mockedDeviceContext, DUMMY_NODE_II, mockedRequestContextFuture);
verify(mockedDeviceContext).writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), eq(DUMMY_NODE_II.augmentation(FlowCapableNode.class)), any(FlowCapableNode.class));
}
private Collection<MultipartReply> prepareDataforTypeDesc(final DeviceContext mockedDeviceContext) {
- MultipartReplyDesc multipartReplyDesc = new MultipartReplyDescBuilder().build();
+ final MultipartReplyDesc multipartReplyDesc = new MultipartReplyDescBuilder().build();
- MultipartReplyDescCaseBuilder multipartReplyDescCaseBuilder = new MultipartReplyDescCaseBuilder();
+ final MultipartReplyDescCaseBuilder multipartReplyDescCaseBuilder = new MultipartReplyDescCaseBuilder();
multipartReplyDescCaseBuilder.setMultipartReplyDesc(multipartReplyDesc);
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyDescCaseBuilder.build()).build();
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyDescCaseBuilder.build()).build();
return Collections.<MultipartReply>singleton(multipartReplyMessage);
}
- protected ConnectionContext buildMockConnectionContext(short ofpVersion) {
+ protected ConnectionContext buildMockConnectionContext(final short ofpVersion) {
when(mockFeatures.getVersion()).thenReturn(ofpVersion);
when(outboundQueueProvider.reserveEntry()).thenReturn(43L);
Mockito.doAnswer(new Answer<Void>() {
@Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
+ public Void answer(final InvocationOnMock invocation) throws Throwable {
final FutureCallback<OfHeader> callBack = (FutureCallback<OfHeader>) invocation.getArguments()[2];
callBack.onSuccess(null);
return null;
when(mockedConnectionAdapter.registerOutboundQueueHandler(Matchers.<OutboundQueueHandler>any(), Matchers.anyInt(), Matchers.anyLong()))
.thenAnswer(new Answer<OutboundQueueHandlerRegistration<OutboundQueueHandler>>() {
@Override
- public OutboundQueueHandlerRegistration<OutboundQueueHandler> answer(InvocationOnMock invocation) throws Throwable {
- OutboundQueueHandler handler = (OutboundQueueHandler) invocation.getArguments()[0];
+ public OutboundQueueHandlerRegistration<OutboundQueueHandler> answer(final InvocationOnMock invocation) throws Throwable {
+ final OutboundQueueHandler handler = (OutboundQueueHandler) invocation.getArguments()[0];
handler.onConnectionQueueChanged(outboundQueueProvider);
return null;
}
package org.opendaylight.openflowplugin.impl.util;
-import static org.mockito.Mockito.any;
+import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-
import java.math.BigInteger;
import org.junit.Test;
+import org.mockito.Matchers;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedConnectionContext);
MdSalRegistrationUtils.registerMasterServices(mockedRpcContext,mockedDeviceContext, OfpRole.BECOMEMASTER);
verify(mockedRpcContext, times(NUMBER_OF_RPC_SERVICE_REGISTRATION)).registerRpcServiceImplementation(
- any(RpcService.class.getClass()), any(RpcService.class));
+ Matchers.<Class<RpcService>> any(), any(RpcService.class));
}
}
Mockito.when(connectionConductor.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
// provider context - registration responder
- Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(Matchers.any(Class.class), Matchers.any(RpcService.class)))
+ Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(Matchers.<Class<RpcService>>any(), Matchers.any(RpcService.class)))
.then(new Answer<RoutedRpcRegistration<?>>() {
@Override
public RoutedRpcRegistration<?> answer(InvocationOnMock invocation) {
when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
when(messageDispatchService.barrier(Mockito.any(BarrierInput.class), Mockito.any(SwitchConnectionDistinguisher.class))).thenReturn(resultListenableFuture);
when(ofRpcTaskContext.getRpcPool()).thenReturn(executorService);
- when(executorService.submit(Mockito.any(Callable.class))).thenReturn(updateFlowRpcResultListenableFuture);
+ when(executorService.submit(Mockito.<Callable<RpcResult<UpdateFlowOutput>>> any())).thenReturn(updateFlowRpcResultListenableFuture);
}
@Test
public void testManageBarrier() throws Exception {
- Collection<RpcError> rpcErrors = OFRpcTaskUtil.manageBarrier(taskContext, true, connectionDistinguisher);
+ final Collection<RpcError> rpcErrors = OFRpcTaskUtil.manageBarrier(taskContext, true, connectionDistinguisher);
assertNotNull(rpcErrors);
}
@Test
public void testHookFutureNotification() throws Exception {
- AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
- OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
+ final AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
+
final OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
OFRpcTaskUtil.hookFutureNotification(addFlowInputRpcResultOFRpcTask, updateFlowRpcResultListenableFuture, notificationProviderService, notificationComposer);
}
@Test
public void testChainFutureBarrier() throws Exception {
- AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
+ final AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
flowInputBuilder.setBarrier(true);
- OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
+
final OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
OFRpcTaskUtil.chainFutureBarrier(addFlowInputRpcResultOFRpcTask, updateFlowRpcResultListenableFuture);
}
}
\ No newline at end of file
*/
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor;
+import com.google.common.collect.ImmutableList;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-
import org.junit.Assert;
import org.junit.Test;
+import org.opendaylight.openflowplugin.openflow.md.util.OpenflowPortsUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GroupModInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.buckets.grouping.BucketsList;
-import com.google.common.collect.ImmutableList;
-
public class GroupConvertorTest {
/**
@Test
public void testGroupModConvertorwithallParameters() {
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupAll);
- List<Bucket> bucketList = new ArrayList<Bucket>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<Bucket> bucketList = new ArrayList<Bucket>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
int actionOrder = 0;
// Action1
- GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
+ final GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
groupActionBuilder.setGroup("005");
- GroupAction groupIdaction = groupActionBuilder.build();
- ActionBuilder actionsB = new ActionBuilder();
+ final GroupAction groupIdaction = groupActionBuilder.build();
+ final ActionBuilder actionsB = new ActionBuilder();
actionsB.setOrder(actionOrder++).setAction(new GroupActionCaseBuilder().setGroupAction(groupIdaction).build());
// Action2:
- GroupActionBuilder groupActionBuilder1 = new GroupActionBuilder();
+ final GroupActionBuilder groupActionBuilder1 = new GroupActionBuilder();
groupActionBuilder1.setGroup("006");
- GroupAction groupIdaction1 = groupActionBuilder.build();
- ActionBuilder actionsB1 = new ActionBuilder();
+ final GroupAction groupIdaction1 = groupActionBuilder.build();
+ final ActionBuilder actionsB1 = new ActionBuilder();
actionsB1.setOrder(actionOrder++).setAction(new GroupActionCaseBuilder().setGroupAction(groupIdaction1).build());
actionsList.add(actionsB.build());
actionsList.add(actionsB1.build());
- BucketsBuilder bucketsB = new BucketsBuilder();
+ final BucketsBuilder bucketsB = new BucketsBuilder();
- BucketBuilder bucketB = new BucketBuilder();
+ final BucketBuilder bucketB = new BucketBuilder();
bucketB.setWeight(10);
bucketB.setWatchPort(20L);
bucketB.setWatchGroup(22L);
bucketB.setAction(actionsList);
- Bucket bucket = bucketB.build();
+ final Bucket bucket = bucketB.build();
bucketList.add(bucket); // List of bucket
- BucketBuilder bucketB1 = new BucketBuilder();
+ final BucketBuilder bucketB1 = new BucketBuilder();
bucketB1.setWeight(50);
bucketB1.setWatchPort(60L);
bucketB1.setWatchGroup(70L);
// Action1
- CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
- CopyTtlIn copyTtl = copyTtlB.build();
- ActionBuilder actionsB2 = new ActionBuilder();
+ final CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
+ final CopyTtlIn copyTtl = copyTtlB.build();
+ final ActionBuilder actionsB2 = new ActionBuilder();
actionsB2.setOrder(actionOrder++).setAction(new CopyTtlInCaseBuilder().setCopyTtlIn(copyTtl).build());
// Action2:
- SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
+ final SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
setMplsTtlActionBuilder.setMplsTtl((short) 0X1);
- SetMplsTtlAction setMAction = setMplsTtlActionBuilder.build();
- ActionBuilder actionsB3 = new ActionBuilder();
+ final SetMplsTtlAction setMAction = setMplsTtlActionBuilder.build();
+ final ActionBuilder actionsB3 = new ActionBuilder();
actionsB3.setOrder(actionOrder++).setAction(new SetMplsTtlActionCaseBuilder().setSetMplsTtlAction(setMAction).build());
bucketB1.setAction(actionsList);
- Bucket bucket1 = bucketB1.build(); // second bucket
+ final Bucket bucket1 = bucketB1.build(); // second bucket
bucketList.add(bucket1);
bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
- Buckets buckets = bucketsB.build();
+ final Buckets buckets = bucketsB.build();
addGroupBuilder.setBuckets(buckets);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
Assert.assertEquals(20L, (long) outAddGroupInput.getBucketsList().get(0).getWatchPort().getValue());
Assert.assertEquals((Long) 22L, outAddGroupInput.getBucketsList().get(0).getWatchGroup());
- List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
+
final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
for (int outItem = 0; outItem < outActionList.size(); outItem++) {
- Action action = outActionList
+ final Action action = outActionList
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
Assert.assertEquals((Integer) 50, outAddGroupInput.getBucketsList().get(1).getWeight());
Assert.assertEquals((long) 60, (long) outAddGroupInput.getBucketsList().get(1).getWatchPort().getValue());
Assert.assertEquals((Long) 70L, outAddGroupInput.getBucketsList().get(1).getWatchGroup());
- List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
+
final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
- Action action = outActionList1
+ final Action action = outActionList1
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
*/
@Test
public void testGroupModConvertorNoBucket() {
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupAll);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
int actionOrder = 0;
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupFf);
- List<Bucket> bucketList = new ArrayList<Bucket>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<Bucket> bucketList = new ArrayList<Bucket>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
// Action1: 005
actionsList.add(assembleActionBuilder("005", actionOrder++).build());
actionsList.add(assembleActionBuilder("006", actionOrder++).build());
// .. and mr.Bond is not coming today
- BucketsBuilder bucketsB = new BucketsBuilder();
+ final BucketsBuilder bucketsB = new BucketsBuilder();
- BucketBuilder bucketB = new BucketBuilder();
+ final BucketBuilder bucketB = new BucketBuilder();
bucketB.setAction(actionsList);
- Bucket bucket = bucketB.build();
+ final Bucket bucket = bucketB.build();
bucketList.add(bucket); // List of bucket
- BucketBuilder bucketB1 = new BucketBuilder();
+ final BucketBuilder bucketB1 = new BucketBuilder();
// Action1
actionsList1.add(assembleCopyTtlInBuilder(actionOrder++).build());
bucketB1.setAction(actionsList1);
- Bucket bucket1 = bucketB1.build(); // second bucket
+ final Bucket bucket1 = bucketB1.build(); // second bucket
bucketList.add(bucket1);
bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
- Buckets buckets = bucketsB.build();
+ final Buckets buckets = bucketsB.build();
addGroupBuilder.setBuckets(buckets);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTFF, outAddGroupInput.getType());
Assert.assertEquals(10L, outAddGroupInput.getGroupId().getValue().longValue());
- List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
+
final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
for (int outItem = 0; outItem < outActionList.size(); outItem++) {
- Action action = outActionList
+ final Action action = outActionList
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
}
}
- List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
+
final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
- Action action = outActionList1
+ final Action action = outActionList1
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 6L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
@Test
public void testGroupModConvertSortedBuckets() {
- int actionOrder = 0;
+ final int actionOrder = 0;
- ArrayList<Bucket> bucket = new ArrayList<Bucket>();
+ final ArrayList<Bucket> bucket = new ArrayList<Bucket>();
bucket.add(new BucketBuilder()
.setBucketId(new BucketId((long) 4))
.build());
- AddGroupInput input = new AddGroupInputBuilder()
+ final AddGroupInput input = new AddGroupInputBuilder()
.setGroupId(new GroupId((long) 1))
.setGroupName("Foo")
.setGroupType(GroupTypes.GroupFf)
.build())
.build();
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(input, (short) 0X4, BigInteger.valueOf(1));
+ OpenflowPortsUtil.init();
+
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(input, (short) 0X4, BigInteger.valueOf(1));
- List<BucketsList> bucketList = outAddGroupInput.getBucketsList();
+ final List<BucketsList> bucketList = outAddGroupInput.getBucketsList();
Assert.assertEquals( Long.valueOf(1), bucketList.get(0).getWatchGroup());
Assert.assertEquals( Long.valueOf(3), bucketList.get(0).getWatchPort().getValue());
/**
* @return
*/
- private static ActionBuilder assembleSetMplsTtlActionBuilder(int actionOrder) {
- SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
+ private static ActionBuilder assembleSetMplsTtlActionBuilder(final int actionOrder) {
+ final SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
setMplsTtlActionBuilder.setMplsTtl((short) 0X1);
- SetMplsTtlActionCaseBuilder setMplsTtlActionCaseBuilder = new SetMplsTtlActionCaseBuilder();
+ final SetMplsTtlActionCaseBuilder setMplsTtlActionCaseBuilder = new SetMplsTtlActionCaseBuilder();
setMplsTtlActionCaseBuilder.setSetMplsTtlAction(setMplsTtlActionBuilder.build());
- ActionBuilder actionsB3 = new ActionBuilder();
+ final ActionBuilder actionsB3 = new ActionBuilder();
actionsB3.setOrder(actionOrder).setAction(setMplsTtlActionCaseBuilder.build());
return actionsB3;
}
/**
* @return
*/
- private static ActionBuilder assembleCopyTtlInBuilder(int actionOrder) {
- CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
- CopyTtlInCaseBuilder copyTtlInCaseBuilder = new CopyTtlInCaseBuilder();
+ private static ActionBuilder assembleCopyTtlInBuilder(final int actionOrder) {
+ final CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
+ final CopyTtlInCaseBuilder copyTtlInCaseBuilder = new CopyTtlInCaseBuilder();
copyTtlInCaseBuilder.setCopyTtlIn(copyTtlB.build());
- ActionBuilder actionsB2 = new ActionBuilder();
+ final ActionBuilder actionsB2 = new ActionBuilder();
actionsB2.setOrder(actionOrder).setAction(copyTtlInCaseBuilder.build());
return actionsB2;
}
* @param groupName name of group
* @return
*/
- private static ActionBuilder assembleActionBuilder(String groupName, int actionOrder) {
- GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
+ private static ActionBuilder assembleActionBuilder(final String groupName, final int actionOrder) {
+ final GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
groupActionBuilder.setGroup(groupName);
- GroupActionCaseBuilder groupActionCaseBuilder = new GroupActionCaseBuilder();
+ final GroupActionCaseBuilder groupActionCaseBuilder = new GroupActionCaseBuilder();
groupActionCaseBuilder.setGroupAction(groupActionBuilder.build());
- ActionBuilder actionsBld = new ActionBuilder();
+ final ActionBuilder actionsBld = new ActionBuilder();
actionsBld.setOrder(actionOrder).setAction(groupActionCaseBuilder.build());
return actionsBld;
}
int actionOrder = 0;
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupAll);
- List<Bucket> bucketList = new ArrayList<Bucket>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<Bucket> bucketList = new ArrayList<Bucket>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
// Action1
actionsList.add(assembleActionBuilder("005", actionOrder++).build());
// Action2:
actionsList.add(assembleActionBuilder("006", actionOrder++).build());
- BucketsBuilder bucketsB = new BucketsBuilder();
+ final BucketsBuilder bucketsB = new BucketsBuilder();
- BucketBuilder bucketB = new BucketBuilder();
+ final BucketBuilder bucketB = new BucketBuilder();
bucketB.setAction(actionsList);
- Bucket bucket = bucketB.build();
+ final Bucket bucket = bucketB.build();
bucketList.add(bucket); // List of bucket
- BucketBuilder bucketB1 = new BucketBuilder();
+ final BucketBuilder bucketB1 = new BucketBuilder();
// Action1
actionsList1.add(assembleCopyTtlInBuilder(actionOrder++).build());
bucketB1.setAction(actionsList);
- Bucket bucket1 = bucketB1.build(); // second bucket
+ final Bucket bucket1 = bucketB1.build(); // second bucket
bucketList.add(bucket1);
bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
- Buckets buckets = bucketsB.build();
+ final Buckets buckets = bucketsB.build();
addGroupBuilder.setBuckets(buckets);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
Assert.assertEquals(10L, outAddGroupInput.getGroupId().getValue().longValue());
- List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
+
final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
for (int outItem = 0; outItem < outActionList.size(); outItem++) {
- Action action = outActionList
+ final Action action = outActionList
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
}
- List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
+
final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
- Action action = outActionList1
+ final Action action = outActionList1
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
*/
package org.opendaylight.openflowplugin.openflow.md.core.session;
+import static org.mockito.Matchers.any;
import com.google.common.util.concurrent.ListeningExecutorService;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import org.junit.After;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor;
import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationEnqueuer;
-import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationQueueWrapper;
import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionContext;
import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionManager;
import org.opendaylight.openflowplugin.api.openflow.md.core.session.SwitchSessionKeyOF;
import org.opendaylight.openflowplugin.openflow.md.core.role.OfEntityManager;
import org.opendaylight.openflowplugin.openflow.md.core.sal.ModelDrivenSwitchImpl;
import org.opendaylight.openflowplugin.openflow.md.core.sal.SalRegistrationManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutputBuilder;
-import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.RpcService;
-import static org.mockito.Matchers.any;
-
/**
* test of {@link SessionManagerOFImpl}
*/
Mockito.when(context.getNotificationEnqueuer()).thenReturn(notificationEnqueuer);
// provider context - registration responder
- Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(any(Class.class), any(RpcService.class)))
+ Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(Matchers.<Class<RpcService>> any(), any(RpcService.class)))
.then(new Answer<RoutedRpcRegistration<?>>() {
@Override
- public RoutedRpcRegistration<?> answer(InvocationOnMock invocation) {
- Object[] args = invocation.getArguments();
- RoutedRpcRegistration<RpcService> registration = Mockito.mock(RoutedRpcRegistration.class);
+ public RoutedRpcRegistration<?> answer(final InvocationOnMock invocation) {
+ final Object[] args = invocation.getArguments();
+ final RoutedRpcRegistration<RpcService> registration = Mockito.mock(RoutedRpcRegistration.class);
Mockito.when(registration.getInstance()).thenReturn((RpcService) args[1]);
return registration;
}
});
// session listener - prepare registration and notification mockery
- SalRegistrationManager sessionListener = new SalRegistrationManager();
+ final SalRegistrationManager sessionListener = new SalRegistrationManager();
sessionListener.setPublishService(notificationProviderService);
sessionListener.setRpcProviderRegistry(rpcProviderRegistry);
sessionListener.setDataService(dataService);
@Test
public void testAddSessionContext() {
// prepare mocks and values
- GetFeaturesOutputBuilder featuresBld = new GetFeaturesOutputBuilder().setDatapathId(BigInteger.valueOf(42));
+ final GetFeaturesOutputBuilder featuresBld = new GetFeaturesOutputBuilder().setDatapathId(BigInteger.valueOf(42));
featuresBld.setVersion((short) 123);
Mockito.when(context.getFeatures()).thenReturn(featuresBld.build());
Mockito.when(primaryConductor.getConnectionAdapter()).thenReturn(connectionAdapter);
@Before
public void setupEnvironment() {
when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.any(InstanceIdentifier.class))).thenReturn(Futures.immediateCheckedFuture(Optional.of(nodes)));
+ when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<Nodes>>any())).thenReturn(Futures.immediateCheckedFuture(Optional.of(nodes)));
OpenflowPortsUtil.init();
OFSessionUtil.getSessionManager().setDataBroker(dataBroker);
*/
@Test
public void testReadNode(){
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.any(InstanceIdentifier.class))).thenReturn(Futures.immediateCheckedFuture(Optional.of(node)));
+ when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<Node>>any())).thenReturn(Futures.immediateCheckedFuture(Optional.of(node)));
InstanceIdentifier<Node> instanceId = InstanceIdentifier.create(Node.class);
Node node = InventoryDataServiceUtil.readNode(instanceId);
assertNotNull(node);
Code Review / openflowplugin.git / commitdiff