.lookup(deviceInfo.getVersion());
if (initializer.isPresent()) {
- final Future<Void> initialize = initializer
- .get()
+ final Future<Void> initialize = initializer.orElseThrow()
.initialize(this, switchFeaturesMandatory, skipTableFeatures, writerProvider, convertorExecutor);
try {
if (result != null) {
for (Optional<FlowCapableNode> optNode : result) {
if (optNode.isPresent()) {
- flowCount += optNode.get().nonnullTable().values().stream()
+ flowCount += optNode.orElseThrow().nonnullTable().values().stream()
.filter(Objects::nonNull)
.flatMap(table -> table.nonnullFlow().values().stream())
.filter(Objects::nonNull)
LOG.warn("An auxiliary connection for device {}, but no primary connection. Refusing connection.",
deviceInfo);
return ConnectionStatus.REFUSING_AUXILIARY_CONNECTION;
+ } else if (contextChain.addAuxiliaryConnection(connectionContext)) {
+ LOG.info("An auxiliary connection was added to device: {}", deviceInfo);
+ return ConnectionStatus.MAY_CONTINUE;
} else {
- if (contextChain.addAuxiliaryConnection(connectionContext)) {
- LOG.info("An auxiliary connection was added to device: {}", deviceInfo);
- return ConnectionStatus.MAY_CONTINUE;
- } else {
- LOG.warn("Not able to add auxiliary connection to the device {}", deviceInfo);
- return ConnectionStatus.REFUSING_AUXILIARY_CONNECTION;
- }
+ LOG.warn("Not able to add auxiliary connection to the device {}", deviceInfo);
+ return ConnectionStatus.REFUSING_AUXILIARY_CONNECTION;
}
} else {
LOG.info("Device {} connected.", deviceInfo);
private @Nullable EntityOwnershipState getCurrentOwnershipStatus(final String nodeId) {
org.opendaylight.mdsal.eos.binding.api.Entity entity = createNodeEntity(nodeId);
- Optional<EntityOwnershipState> ownershipStatus
+ Optional<EntityOwnershipState> optOwnershipStatus
= entityOwnershipService.getOwnershipState(entity);
- if (ownershipStatus.isPresent()) {
- LOG.debug("Current ownership status for node {} is {}", nodeId, ownershipStatus.get());
- return ownershipStatus.get();
+ if (optOwnershipStatus.isPresent()) {
+ final var ownershipStatus = optOwnershipStatus.orElseThrow();
+ LOG.debug("Current ownership status for node {} is {}", nodeId, ownershipStatus);
+ return ownershipStatus;
}
LOG.trace("Ownership status is not available for node {}", nodeId);
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.text.SimpleDateFormat;
-import java.util.Collections;
import java.util.Date;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
final List<DataContainer> allMultipartData = rpcResult.getResult().stream()
.map(reply -> MultipartReplyTranslatorUtil
.translate(reply, deviceInfo, convertorExecutor, null))
- .filter(Optional::isPresent).map(Optional::get)
+ .filter(Optional::isPresent).map(Optional::orElseThrow)
.collect(Collectors.toList());
return processStatistics(type, allMultipartData, txFacade, registry, deviceInfo,
// we have to read actual tables with all information before we set empty Flow list,
// merge is expensive and not applicable for lists
if (flowCapNodeOpt != null && flowCapNodeOpt.isPresent()) {
- for (final Table tableData : flowCapNodeOpt.get().nonnullTable().values()) {
- final Table table = new TableBuilder(tableData).setFlow(Collections.emptyMap()).build();
+ for (final Table tableData : flowCapNodeOpt.orElseThrow().nonnullTable().values()) {
+ final Table table = new TableBuilder(tableData).setFlow(Map.of()).build();
final InstanceIdentifier<Table> iiToTable = instanceIdentifier
.child(Table.class, tableData.key());
txFacade.writeToTransaction(LogicalDatastoreType.OPERATIONAL, iiToTable, table);
provider.register(OFConstants.OFP_VERSION_1_3, abstractDeviceInitializer);
final Optional<AbstractDeviceInitializer> lookup = provider.lookup(OFConstants.OFP_VERSION_1_3);
assertTrue(lookup.isPresent());
- assertEquals(abstractDeviceInitializer, lookup.get());
+ assertEquals(abstractDeviceInitializer, lookup.orElseThrow());
}
@Test
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_OP);
Optional<SetFieldMatch> fieldMatch = deserializer.deserialize(buffer);
- assertEquals(ArpOp.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(ArpOp.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_SHA);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(ArpSha.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(ArpSha.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_SPA);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(ArpSpa.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(ArpSpa.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_THA);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(ArpTha.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(ArpTha.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_TPA);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(ArpTpa.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(ArpTpa.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ETH_DST);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(EthDst.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(EthDst.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ETH_SRC);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(EthSrc.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(EthSrc.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV4_CODE);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Icmpv4Code.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Icmpv4Code.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV4_TYPE);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Icmpv4Type.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Icmpv4Type.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV6_CODE);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Icmpv6Code.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Icmpv6Code.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV6_TYPE);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Icmpv6Type.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Icmpv6Type.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IN_PHY_PORT);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(InPhyPort.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(InPhyPort.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IN_PORT);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(InPort.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(InPort.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IP_DSCP);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(IpDscp.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(IpDscp.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IP_ECN);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(IpEcn.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(IpEcn.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IP_PROTO);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(IpProto.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(IpProto.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV4_SRC);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv4Src.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv4Src.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV4_DST);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv4Dst.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv4Dst.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_SRC);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv6Src.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv6Src.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_DST);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv6Dst.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv6Dst.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_EXTHDR);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv6Exthdr.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv6Exthdr.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_FLABEL);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv6Flabel.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv6Flabel.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_ND_SLL);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv6NdSll.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv6NdSll.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_ND_TLL);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv6NdTll.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv6NdTll.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_ND_TARGET);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Ipv6NdTarget.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Ipv6NdTarget.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.METADATA);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(Metadata.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(Metadata.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.MPLS_BOS);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(MplsBos.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(MplsBos.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.MPLS_LABEL);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(MplsLabel.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(MplsLabel.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.MPLS_TC);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(MplsTc.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(MplsTc.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.PBB_ISID);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(PbbIsid.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(PbbIsid.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.SCTP_SRC);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(SctpSrc.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(SctpSrc.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.SCTP_DST);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(SctpDst.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(SctpDst.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.TCP_SRC);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(TcpSrc.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(TcpSrc.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.TCP_DST);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(TcpDst.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(TcpDst.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.TUNNEL_ID);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(TunnelId.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(TunnelId.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.UDP_SRC);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(UdpSrc.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(UdpSrc.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.UDP_DST);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(UdpDst.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(UdpDst.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.VLAN_PCP);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(VlanPcp.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(VlanPcp.VALUE, fieldMatch.orElseThrow().key().getMatchType());
addValues(buffer, OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.VLAN_VID);
fieldMatch = deserializer.deserialize(buffer);
- assertEquals(VlanVid.VALUE, fieldMatch.get().key().getMatchType());
+ assertEquals(VlanVid.VALUE, fieldMatch.orElseThrow().key().getMatchType());
assertEquals(0, buffer.readableBytes());
}
- private static void addValues(ByteBuf buffer, int oxmClass, int oxmField) {
+ private static void addValues(final ByteBuf buffer, final int oxmClass, final int oxmField) {
buffer.clear();
buffer.writeShort(oxmClass);
buffer.writeByte(oxmField << 1);
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import com.google.common.collect.Lists;
-import java.util.Collections;
+import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
multipartReplyMessage,
mockedDeviceContext.getDeviceInfo(),
CONVERTOR_MANAGER,
- mockedDeviceContext.oook()).get();
+ mockedDeviceContext.oook()).orElseThrow();
DataContainer dataObject = validateOutput(result);
assertTrue(dataObject instanceof FlowAndStatisticsMapList);
multipartReplyMessage,
mockedDeviceContext.getDeviceInfo(),
CONVERTOR_MANAGER,
- mockedDeviceContext.oook()).get();
+ mockedDeviceContext.oook()).orElseThrow();
DataContainer dataObject = validateOutput(result);
assertTrue(dataObject instanceof AggregateFlowStatistics);
multipartReplyMessage,
mockedDeviceContext.getDeviceInfo(),
CONVERTOR_MANAGER,
- mockedDeviceContext.oook()).get();
+ mockedDeviceContext.oook()).orElseThrow();
DataContainer dataObject = validateOutput(result);
assertTrue(dataObject instanceof org.opendaylight.yang.gen.v1.urn
multipartReplyMessage,
mockedDeviceContext.getDeviceInfo(),
CONVERTOR_MANAGER,
- mockedDeviceContext.oook()).get();
+ mockedDeviceContext.oook()).orElseThrow();
DataContainer dataObject = validateOutput(result);
assertTrue(dataObject instanceof GroupStatisticsReply);
multipartReplyMessage,
mockedDeviceContext.getDeviceInfo(),
CONVERTOR_MANAGER,
- mockedDeviceContext.oook()).get();
+ mockedDeviceContext.oook()).orElseThrow();
DataContainer dataObject = validateOutput(result);
assertTrue(dataObject instanceof GroupDescStatsReply);
}
private static MultipartReplyBody prepareMultipartReplyGroupDesc() {
- GroupDescBuilder groupDescBuilder = new GroupDescBuilder();
- groupDescBuilder.setGroupId(DUMMY_GROUP_ID);
- groupDescBuilder.setBucketsList(Collections.emptyList());
- groupDescBuilder.setType(DUMMY_GROUP_TYPE);
- MultipartReplyGroupDescBuilder multipartReplyGroupDescBuilder = new MultipartReplyGroupDescBuilder();
- multipartReplyGroupDescBuilder.setGroupDesc(Lists.newArrayList(groupDescBuilder.build()));
+ GroupDescBuilder groupDescBuilder = new GroupDescBuilder()
+ .setGroupId(DUMMY_GROUP_ID)
+ .setBucketsList(List.of())
+ .setType(DUMMY_GROUP_TYPE);
+ MultipartReplyGroupDescBuilder multipartReplyGroupDescBuilder = new MultipartReplyGroupDescBuilder()
+ .setGroupDesc(List.of(groupDescBuilder.build()));
MultipartReplyGroupDescCaseBuilder multipartReplyGroupDescCaseBuilder =
new MultipartReplyGroupDescCaseBuilder();
multipartReplyGroupDescCaseBuilder.setMultipartReplyGroupDesc(multipartReplyGroupDescBuilder.build());
private static MultipartReplyBody prepareMultipartReplyGroup() {
GroupStatsBuilder groupStatsBuilder = new GroupStatsBuilder();
groupStatsBuilder.setByteCount(DUMMY_BYTE_COUNT);
- groupStatsBuilder.setBucketStats(Collections.emptyList());
+ groupStatsBuilder.setBucketStats(List.of());
groupStatsBuilder.setDurationSec(DUMMY_DURATION_SEC);
groupStatsBuilder.setDurationNsec(DUMMY_DURATION_NSEC);
groupStatsBuilder.setGroupId(DUMMY_GROUP_ID);
groupStatsBuilder.setPacketCount(DUMMY_PACKET_COUNT);
groupStatsBuilder.setRefCount(DUMMY_REF_COUNT);
- MultipartReplyGroupBuilder multipartReplyGroupBuilder = new MultipartReplyGroupBuilder();
- multipartReplyGroupBuilder.setGroupStats(Lists.newArrayList(groupStatsBuilder.build()));
+ MultipartReplyGroupBuilder multipartReplyGroupBuilder = new MultipartReplyGroupBuilder()
+ .setGroupStats(List.of(groupStatsBuilder.build()));
MultipartReplyGroupCaseBuilder multipartReplyGroupCaseBuilder = new MultipartReplyGroupCaseBuilder();
multipartReplyGroupCaseBuilder.setMultipartReplyGroup(multipartReplyGroupBuilder.build());
return multipartReplyGroupCaseBuilder.build();
dummyPortStatBuilder.setRxOverErr(DUMMY_OVER_ERR);
dummyPortStatBuilder.setTxDropped(DUMMY_TX_DROPPED);
dummyPortStatBuilder.setTxErrors(DUMMY_TX_ERRORS);
- MultipartReplyPortStatsBuilder multipartReplyPortStatsBuilder = new MultipartReplyPortStatsBuilder();
- multipartReplyPortStatsBuilder.setPortStats(Lists.newArrayList(dummyPortStatBuilder.build()));
+ MultipartReplyPortStatsBuilder multipartReplyPortStatsBuilder = new MultipartReplyPortStatsBuilder()
+ .setPortStats(List.of(dummyPortStatBuilder.build()));
MultipartReplyPortStatsCaseBuilder multipartReplyPortStatsCaseBuilder =
new MultipartReplyPortStatsCaseBuilder();
multipartReplyPortStatsCaseBuilder.setMultipartReplyPortStats(multipartReplyPortStatsBuilder.build());
private static MultipartReplyBody prepareMultipartReplyFlow() {
MultipartReplyFlowCaseBuilder multipartReplyFlowCaseBuilder = new MultipartReplyFlowCaseBuilder();
MultipartReplyFlowBuilder multipartReplyFlowBuilder = new MultipartReplyFlowBuilder();
- multipartReplyFlowBuilder.setFlowStats(Collections.emptyList());
+ multipartReplyFlowBuilder.setFlowStats(List.of());
multipartReplyFlowCaseBuilder.setMultipartReplyFlow(multipartReplyFlowBuilder.build());
return multipartReplyFlowCaseBuilder.build();
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
final ArgumentCaptor<InstanceIdentifier> flowPath = ArgumentCaptor.forClass(InstanceIdentifier.class);
final ArgumentCaptor<Flow> flow = ArgumentCaptor.forClass(Flow.class);
- provider.lookup(MultipartType.OFPMPFLOW).get().write(prepareFlowStatisticsData().iterator().next(), false);
+ provider.lookup(MultipartType.OFPMPFLOW).orElseThrow().write(prepareFlowStatisticsData().iterator().next(),
+ false);
Mockito.verify(deviceContext).writeToTransaction(
dataStoreType.capture(), flowPath.capture(), flow.capture());
flowAndStatsMapListBld.setMatch(new MatchBuilder().build());
final FlowsStatisticsUpdateBuilder flowStatsUpdateBld1 = new FlowsStatisticsUpdateBuilder();
- flowStatsUpdateBld1.setFlowAndStatisticsMapList(Lists.newArrayList(flowAndStatsMapListBld.build()));
+ flowStatsUpdateBld1.setFlowAndStatisticsMapList(List.of(flowAndStatsMapListBld.build()));
- return Lists.newArrayList(flowStatsUpdateBld1.build());
+ return List.of(flowStatsUpdateBld1.build());
}
-
@Test
public void testGatherStatistics_group() throws Exception {
final MultipartType type = MultipartType.OFPMPGROUP;
final Uint32 groupIdValue = Uint32.valueOf(19);
final GroupStatsBuilder groupStatsBld = new GroupStatsBuilder()
- .setBucketStats(Lists.newArrayList(createBucketStat(21L, 42L)))
+ .setBucketStats(List.of(createBucketStat(21L, 42L)))
.setByteCount(Uint64.valueOf(84))
.setPacketCount(Uint64.valueOf(63))
.setDurationSec(Uint32.valueOf(11))
.setRefCount(Uint32.valueOf(13))
.setGroupId(new GroupId(groupIdValue));
final MultipartReplyGroupBuilder mpReplyGroupBld = new MultipartReplyGroupBuilder();
- mpReplyGroupBld.setGroupStats(Lists.newArrayList(groupStatsBld.build()));
+ mpReplyGroupBld.setGroupStats(List.of(groupStatsBld.build()));
final MultipartReplyGroupCaseBuilder mpReplyGroupCaseBld = new MultipartReplyGroupCaseBuilder();
mpReplyGroupCaseBld.setMultipartReplyGroup(mpReplyGroupBld.build());
final MultipartReply groupStatsUpdated = assembleMPReplyMessage(type, mpReplyGroupCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(groupStatsUpdated);
+ final List<MultipartReply> statsData = List.of(groupStatsUpdated);
fireAndCheck(type, statsData);
final BucketsListBuilder bucketsListBld = new BucketsListBuilder()
.setWatchPort(new PortNumber(Uint32.valueOf(5)));
final GroupDescBuilder groupStatsBld = new GroupDescBuilder()
- .setBucketsList(Lists.newArrayList(bucketsListBld.build()))
+ .setBucketsList(List.of(bucketsListBld.build()))
.setGroupId(new GroupId(groupIdValue))
.setType(GroupType.OFPGTALL);
final MultipartReplyGroupDescBuilder mpReplyGroupBld = new MultipartReplyGroupDescBuilder();
- mpReplyGroupBld.setGroupDesc(Lists.newArrayList(groupStatsBld.build()));
+ mpReplyGroupBld.setGroupDesc(List.of(groupStatsBld.build()));
final MultipartReplyGroupDescCaseBuilder mpReplyGroupCaseBld = new MultipartReplyGroupDescCaseBuilder();
mpReplyGroupCaseBld.setMultipartReplyGroupDesc(mpReplyGroupBld.build());
final MultipartReply groupStatsUpdated = assembleMPReplyMessage(type, mpReplyGroupCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(groupStatsUpdated);
+ final List<MultipartReply> statsData = List.of(groupStatsUpdated);
fireAndCheck(type, statsData);
.setDurationNsec(Uint32.valueOf(113))
.setFlowCount(Uint32.valueOf(114))
.setPacketInCount(Uint64.valueOf(115))
- .setMeterBandStats(Lists.newArrayList(meterBandStatsBld.build()));
+ .setMeterBandStats(List.of(meterBandStatsBld.build()));
final MultipartReplyMeterBuilder mpReplyMeterBld = new MultipartReplyMeterBuilder();
- mpReplyMeterBld.setMeterStats(Lists.newArrayList(meterStatsBld.build()));
+ mpReplyMeterBld.setMeterStats(List.of(meterStatsBld.build()));
final MultipartReplyMeterCaseBuilder mpReplyMeterCaseBld = new MultipartReplyMeterCaseBuilder();
mpReplyMeterCaseBld.setMultipartReplyMeter(mpReplyMeterBld.build());
final MultipartReply meterStatsUpdated = assembleMPReplyMessage(type, mpReplyMeterCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(meterStatsUpdated);
+ final List<MultipartReply> statsData = List.of(meterStatsUpdated);
fireAndCheck(type, statsData);
final PortStatsBuilder portStatsBld = new PortStatsBuilder()
.setPortNo(Uint32.valueOf(11));
final MultipartReplyPortStatsBuilder mpReplyMeterBld = new MultipartReplyPortStatsBuilder();
- mpReplyMeterBld.setPortStats(Lists.newArrayList(portStatsBld.build()));
+ mpReplyMeterBld.setPortStats(List.of(portStatsBld.build()));
final MultipartReplyPortStatsCaseBuilder mpReplyMeterCaseBld = new MultipartReplyPortStatsCaseBuilder();
mpReplyMeterCaseBld.setMultipartReplyPortStats(mpReplyMeterBld.build());
final MultipartReply meterStatsUpdated = assembleMPReplyMessage(type, mpReplyMeterCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(meterStatsUpdated);
+ final List<MultipartReply> statsData = List.of(meterStatsUpdated);
fireAndCheck(type, statsData);
.setMatchedCount(Uint64.valueOf(35))
.setTableId(Uint8.ZERO);
final MultipartReplyTableBuilder mpReplyTableBld = new MultipartReplyTableBuilder();
- mpReplyTableBld.setTableStats(Lists.newArrayList(tableStatsBld.build()));
+ mpReplyTableBld.setTableStats(List.of(tableStatsBld.build()));
final MultipartReplyTableCaseBuilder mpReplyTableCaseBld = new MultipartReplyTableCaseBuilder();
mpReplyTableCaseBld.setMultipartReplyTable(mpReplyTableBld.build());
final MultipartReply meterStatsUpdated = assembleMPReplyMessage(type, mpReplyTableCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(meterStatsUpdated);
+ final List<MultipartReply> statsData = List.of(meterStatsUpdated);
fireAndCheck(type, statsData);
.setQueueId(queueIdValue);
final MultipartReplyQueueBuilder mpReplyQueueBld = new MultipartReplyQueueBuilder();
- mpReplyQueueBld.setQueueStats(Lists.newArrayList(queueStatsBld.build()));
+ mpReplyQueueBld.setQueueStats(List.of(queueStatsBld.build()));
final MultipartReplyQueueCaseBuilder mpReplyQueueCaseBld = new MultipartReplyQueueCaseBuilder();
mpReplyQueueCaseBld.setMultipartReplyQueue(mpReplyQueueBld.build());
final MultipartReply meterStatsUpdated = assembleMPReplyMessage(type, mpReplyQueueCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(meterStatsUpdated);
+ final List<MultipartReply> statsData = List.of(meterStatsUpdated);
fireAndCheck(type, statsData);
final org.opendaylight.yang.gen.v1.urn
.opendaylight.openflow.oxm.rev150225.match.grouping.MatchBuilder matchBld =
new org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.grouping.MatchBuilder()
- .setMatchEntry(Collections.emptyList());
+ .setMatchEntry(List.of());
final FlowStatsBuilder flowStatsBld = new FlowStatsBuilder()
.setByteCount(Uint64.valueOf(55))
.setPacketCount(Uint64.valueOf(56))
.setFlags(new FlowModFlags(true, false, false, false, true));
final MultipartReplyFlowBuilder mpReplyFlowBld = new MultipartReplyFlowBuilder();
- mpReplyFlowBld.setFlowStats(Lists.newArrayList(flowStatsBld.build()));
+ mpReplyFlowBld.setFlowStats(List.of(flowStatsBld.build()));
final MultipartReplyFlowCaseBuilder mpReplyFlowCaseBld = new MultipartReplyFlowCaseBuilder();
mpReplyFlowCaseBld.setMultipartReplyFlow(mpReplyFlowBld.build());
final MultipartReply flowStatsUpdated = assembleMPReplyMessage(type, mpReplyFlowCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(flowStatsUpdated);
+ final List<MultipartReply> statsData = List.of(flowStatsUpdated);
fireAndCheck(type, statsData);
final FlowBuilder flowBld = new FlowBuilder()
final MeterConfigBuilder meterConfigBld = new MeterConfigBuilder()
.setMeterId(new MeterId(meterIdValue))
.setFlags(new MeterFlags(false, true, false, true))
- .setBands(Collections.emptyList());
+ .setBands(List.of());
final MultipartReplyMeterConfigBuilder mpReplyMeterConfigBld = new MultipartReplyMeterConfigBuilder();
- mpReplyMeterConfigBld.setMeterConfig(Lists.newArrayList(meterConfigBld.build()));
+ mpReplyMeterConfigBld.setMeterConfig(List.of(meterConfigBld.build()));
final MultipartReplyMeterConfigCaseBuilder mpReplyMeterConfigCaseBld =
new MultipartReplyMeterConfigCaseBuilder();
mpReplyMeterConfigCaseBld.setMultipartReplyMeterConfig(mpReplyMeterConfigBld.build());
final MultipartReply meterConfigUpdated = assembleMPReplyMessage(type, mpReplyMeterConfigCaseBld.build());
- final List<MultipartReply> statsData = Collections.singletonList(meterConfigUpdated);
+ final List<MultipartReply> statsData = List.of(meterConfigUpdated);
fireAndCheck(type, statsData);
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
.setFlags(mock(FlowModFlags.class))
.setMatch(new org.opendaylight.yang.gen.v1.urn
.opendaylight.openflow.oxm.rev150225.match.grouping.MatchBuilder()
- .setMatchEntry(Collections.emptyList())
+ .setMatchEntry(List.of())
.build())
.build();
- final List<FlowStats> flowStats = Collections.singletonList(flowStat);
- final List<MultipartReply> input = Collections.singletonList(reply);
+ final List<FlowStats> flowStats = List.of(flowStat);
+ final List<MultipartReply> input = List.of(reply);
when(flow.getFlowStats()).thenReturn(flowStats);
when(flowCase.getMultipartReplyFlow()).thenReturn(flow);
when(stat.getTableId()).thenReturn(TABLE_NO);
when(stat.getMatch()).thenReturn(new MatchBuilder().build());
- final List<FlowAndStatisticsMapList> stats = Collections.singletonList(stat);
+ final List<FlowAndStatisticsMapList> stats = List.of(stat);
final GetFlowStatisticsOutput output = mock(GetFlowStatisticsOutput.class);
when(output.nonnullFlowAndStatisticsMapList()).thenReturn(stats);
- multipartWriterProvider.lookup(MultipartType.OFPMPFLOW).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPFLOW).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.group._case.multipart.reply.group.GroupStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestGroupCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.group._case.MultipartRequestGroup;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
.opendaylight.openflow.common.types.rev130731.GroupId(GROUP_NO))
.setByteCount(Uint64.ONE)
.setPacketCount(Uint64.ONE)
- .setBucketStats(Collections.emptyList())
+ .setBucketStats(List.of())
.setDurationSec(Uint32.ONE)
.setDurationNsec(Uint32.ONE)
.setRefCount(Uint32.ZERO)
.build();
- final List<GroupStats> groupStats = Collections.singletonList(groupStat);
- final List<MultipartReply> input = Collections.singletonList(reply);
+ final List<GroupStats> groupStats = List.of(groupStat);
+ final List<MultipartReply> input = List.of(reply);
when(group.getGroupStats()).thenReturn(groupStats);
when(groupCase.getMultipartReplyGroup()).thenReturn(group);
.GroupStatsBuilder().setGroupId(new GroupId(GROUP_NO)).build();
final GetGroupStatisticsOutput output = mock(GetGroupStatisticsOutput.class);
- when(output.nonnullGroupStats()).thenReturn(Collections.singletonMap(stat.key(), stat));
+ when(output.nonnullGroupStats()).thenReturn(BindingMap.of(stat));
- multipartWriterProvider.lookup(MultipartType.OFPMPGROUP).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPGROUP).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.meter._case.multipart.reply.meter.MeterStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestMeterCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.meter._case.MultipartRequestMeter;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
final MeterStats meterStat = new MeterStatsBuilder().setMeterId(
new org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterId(METER_NO))
.setByteInCount(Uint64.ONE).setPacketInCount(Uint64.ONE).setDurationSec(Uint32.ONE)
- .setDurationNsec(Uint32.ONE).setFlowCount(Uint32.ZERO).setMeterBandStats(Collections.emptyList())
+ .setDurationNsec(Uint32.ONE).setFlowCount(Uint32.ZERO).setMeterBandStats(List.of())
.build();
- final List<MeterStats> meterStats = Collections.singletonList(meterStat);
- final List<MultipartReply> input = Collections.singletonList(reply);
+ final List<MeterStats> meterStats = List.of(meterStat);
+ final List<MultipartReply> input = List.of(reply);
when(meter.getMeterStats()).thenReturn(meterStats);
when(MeterCase.getMultipartReplyMeter()).thenReturn(meter);
final Map<MeterStatsKey,
org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats>
- stats = Collections.singletonMap(stat.key(), stat);
+ stats = BindingMap.of(stat);
final GetMeterStatisticsOutput output = mock(GetMeterStatisticsOutput.class);
when(output.nonnullMeterStats()).thenReturn(stats);
- multipartWriterProvider.lookup(MultipartType.OFPMPMETER).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPMETER).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.port.stats._case.MultipartRequestPortStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMapKey;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
final MultipartReplyPortStatsCase nodeConnectorCase = mock(MultipartReplyPortStatsCase.class);
final MultipartReplyPortStats nodeConnector = mock(MultipartReplyPortStats.class);
final PortStats nodeConnectorStat = mock(PortStats.class);
- final List<PortStats> nodeConnectorStats = Collections.singletonList(nodeConnectorStat);
- final List<MultipartReply> input = Collections.singletonList(reply);
+ final List<PortStats> nodeConnectorStats = List.of(nodeConnectorStat);
+ final List<MultipartReply> input = List.of(reply);
when(nodeConnector.getPortStats()).thenReturn(nodeConnectorStats);
when(nodeConnector.nonnullPortStats()).thenCallRealMethod();
when(stat.getNodeConnectorId()).thenReturn(nodeConnectorId);
final Map<NodeConnectorStatisticsAndPortNumberMapKey, NodeConnectorStatisticsAndPortNumberMap> stats
- = Collections.singletonMap(stat.key(), stat);
+ = BindingMap.of(stat);
final GetNodeConnectorStatisticsOutput output = mock(GetNodeConnectorStatisticsOutput.class);
when(output.nonnullNodeConnectorStatisticsAndPortNumberMap()).thenReturn(stats);
- multipartWriterProvider.lookup(MultipartType.OFPMPPORTSTATS).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPPORTSTATS).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.queue._case.MultipartRequestQueue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMapKey;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
final MultipartReplyQueueCase queueCase = mock(MultipartReplyQueueCase.class);
final MultipartReplyQueue queue = mock(MultipartReplyQueue.class);
final QueueStats queueStat = mock(QueueStats.class);
- final List<QueueStats> queueStats = Collections.singletonList(queueStat);
- final List<MultipartReply> input = Collections.singletonList(reply);
+ final List<QueueStats> queueStats = List.of(queueStat);
+ final List<MultipartReply> input = List.of(reply);
when(queue.getQueueStats()).thenReturn(queueStats);
when(queue.nonnullQueueStats()).thenCallRealMethod();
when(map.getNodeConnectorId()).thenReturn(new NodeConnectorId("1"));
when(map.key()).thenReturn(new QueueIdAndStatisticsMapKey(new NodeConnectorId("1"), new QueueId(QUEUE_NO)));
- final Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> maps
- = Collections.singletonMap(map.key(), map);
+ final Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> maps = BindingMap.of(map);
final GetQueueStatisticsOutput output = mock(GetQueueStatisticsOutput.class);
when(output.nonnullQueueIdAndStatisticsMap()).thenReturn(maps);
- multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
when(map.key()).thenReturn(new QueueIdAndStatisticsMapKey(new NodeConnectorId("openflow:1:1"),
new QueueId(QUEUE_NO)));
- final Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> maps
- = Collections.singletonMap(map.key(), map);
+ final Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> maps = BindingMap.of(map);
final GetQueueStatisticsOutput output = mock(GetQueueStatisticsOutput.class);
when(output.nonnullQueueIdAndStatisticsMap()).thenReturn(maps);
- multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.mockito.Mockito.when;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
final MultipartReply reply = new MultipartReplyBuilder()
.setMultipartReplyBody(new MultipartReplyFlowStatsBuilder()
- .setFlowAndStatisticsMapList(Collections.singletonList(flowStat))
+ .setFlowAndStatisticsMapList(List.of(flowStat))
.build())
.build();
final MultipartReply reply1 = new MultipartReplyBuilder()
.setMultipartReplyBody(new MultipartReplyFlowStatsBuilder()
- .setFlowAndStatisticsMapList(Collections.singletonList(flowStat1))
+ .setFlowAndStatisticsMapList(List.of(flowStat1))
.build())
.build();
final List<MultipartReply> input = new ArrayList<>();
when(stat.getTableId()).thenReturn(TABLE_NO);
when(stat.getMatch()).thenReturn(new MatchBuilder().build());
- final List<FlowAndStatisticsMapList> stats
- = Collections.singletonList(stat);
+ final List<FlowAndStatisticsMapList> stats = List.of(stat);
final GetFlowStatisticsOutput output = mock(GetFlowStatisticsOutput.class);
when(output.nonnullFlowAndStatisticsMapList()).thenReturn(stats);
- multipartWriterProvider.lookup(MultipartType.OFPMPFLOW).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPFLOW).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
-import java.util.Map;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetGroupStatisticsInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetGroupStatisticsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetGroupStatisticsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetGroupStatisticsOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.multipart.reply.multipart.reply.body.MultipartReplyGroupStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.multipart.request.multipart.request.body.MultipartRequestGroupStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStatsKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
public class GroupDirectStatisticsServiceTest extends AbstractDirectStatisticsServiceTest {
@Override
public void testBuildRequestBody() {
- final GetGroupStatisticsInput input = mock(GetGroupStatisticsInput.class);
-
- lenient().when(input.getNode()).thenReturn(createNodeRef(NODE_ID));
- when(input.getGroupId()).thenReturn(new GroupId(GROUP_NO));
-
final MultipartRequestGroupStats body = (MultipartRequestGroupStats) ((MultipartRequest) service
- .buildRequest(new Xid(Uint32.valueOf(42L)), input))
+ .buildRequest(new Xid(Uint32.valueOf(42L)), new GetGroupStatisticsInputBuilder()
+ .setGroupId(new GroupId(GROUP_NO))
+ .setNode(createNodeRef(NODE_ID))
+ .build()))
.getMultipartRequestBody();
assertEquals(GROUP_NO, body.getGroupId().getValue());
@Override
public void testBuildReply() {
- final GroupStats groupStat = new GroupStatsBuilder()
- .setGroupId(new GroupId(GROUP_NO))
- .build();
-
- final MultipartReply reply = new MultipartReplyBuilder()
- .setMultipartReplyBody(new MultipartReplyGroupStatsBuilder()
- .setGroupStats(Collections.singletonMap(groupStat.key(), groupStat))
- .build())
- .build();
-
- final List<MultipartReply> input = Collections.singletonList(reply);
-
- final GetGroupStatisticsOutput output = service.buildReply(input, true);
+ final var output = service.buildReply(List.of(new MultipartReplyBuilder()
+ .setMultipartReplyBody(new MultipartReplyGroupStatsBuilder()
+ .setGroupStats(BindingMap.of(new GroupStatsBuilder()
+ .setGroupId(new GroupId(GROUP_NO))
+ .build()))
+ .build())
+ .build()), true);
assertTrue(output.nonnullGroupStats().size() > 0);
- final org.opendaylight.yang.gen.v1.urn
- .opendaylight.group.types.rev131018.group.statistics.reply.GroupStats stats =
- output.nonnullGroupStats().values().iterator().next();
+ final var stats = output.nonnullGroupStats().values().iterator().next();
assertEquals(stats.getGroupId().getValue(), GROUP_NO);
}
@Override
public void testStoreStatistics() {
- final org.opendaylight.yang.gen.v1.urn
- .opendaylight.group.types.rev131018.group.statistics.reply.GroupStats stat =
- mock(org.opendaylight.yang.gen.v1.urn
- .opendaylight.group.types.rev131018.group.statistics.reply.GroupStats.class);
- when(stat.getGroupId()).thenReturn(new GroupId(GROUP_NO));
-
- final Map<GroupStatsKey, GroupStats> stats = Collections.singletonMap(stat.key(), stat);
- final GetGroupStatisticsOutput output = mock(GetGroupStatisticsOutput.class);
- when(output.nonnullGroupStats()).thenReturn(stats);
-
- multipartWriterProvider.lookup(MultipartType.OFPMPGROUP).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPGROUP).orElseThrow()
+ .write(new GetGroupStatisticsOutputBuilder()
+ .setGroupStats(BindingMap.of(new org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018
+ .group.statistics.reply.GroupStatsBuilder().setGroupId(new GroupId(GROUP_NO)).build()))
+ .build(), true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
-import java.util.Map;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter32;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter64;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetMeterStatisticsInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetMeterStatisticsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetMeterStatisticsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetMeterStatisticsOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.multipart.reply.multipart.reply.body.MultipartReplyMeterStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.multipart.request.multipart.request.body.MultipartRequestMeterStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.MeterBandStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStatsKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
@Override
public void testBuildRequestBody() {
- final GetMeterStatisticsInput input = mock(GetMeterStatisticsInput.class);
-
- lenient().when(input.getNode()).thenReturn(createNodeRef(NODE_ID));
- when(input.getMeterId()).thenReturn(new MeterId(METER_NO));
-
- final MultipartRequestMeterStats body = (MultipartRequestMeterStats) ((MultipartRequest) service
- .buildRequest(new Xid(Uint32.valueOf(42L)), input))
+ final var body = (MultipartRequestMeterStats) ((MultipartRequest) service
+ .buildRequest(new Xid(Uint32.valueOf(42L)), new GetMeterStatisticsInputBuilder()
+ .setMeterId(new MeterId(METER_NO))
+ .setNode(createNodeRef(NODE_ID))
+ .build()))
.getMultipartRequestBody();
assertEquals(METER_NO, body.getStatMeterId().getValue());
@Override
public void testBuildReply() {
- final MeterStats meterStat = new MeterStatsBuilder()
- .setMeterId(new MeterId(METER_NO))
- .setByteInCount(new Counter64(Uint64.ONE))
- .setPacketInCount(new Counter64(Uint64.ONE))
- .setDuration(new DurationBuilder()
+ final var output = service.buildReply(List.of(new MultipartReplyBuilder()
+ .setMultipartReplyBody(new MultipartReplyMeterStatsBuilder()
+ .setMeterStats(BindingMap.of(new MeterStatsBuilder()
+ .setMeterId(new MeterId(METER_NO))
+ .setByteInCount(new Counter64(Uint64.ONE))
+ .setPacketInCount(new Counter64(Uint64.ONE))
+ .setDuration(new DurationBuilder()
.setSecond(new Counter32(Uint32.ONE))
.setNanosecond(new Counter32(Uint32.ONE))
.build())
- .setFlowCount(new Counter32(Uint32.ZERO))
- .setMeterBandStats(new MeterBandStatsBuilder().build())
- .build();
-
- final MultipartReply reply = new MultipartReplyBuilder()
- .setMultipartReplyBody(new MultipartReplyMeterStatsBuilder()
- .setMeterStats(Collections.singletonMap(meterStat.key(), meterStat))
- .build())
- .build();
-
- final List<MultipartReply> input = Collections.singletonList(reply);
-
- final GetMeterStatisticsOutput output = service.buildReply(input, true);
+ .setFlowCount(new Counter32(Uint32.ZERO))
+ .setMeterBandStats(new MeterBandStatsBuilder().build())
+ .build()))
+ .build())
+ .build()), true);
assertTrue(output.nonnullMeterStats().size() > 0);
final MeterStats stats = output.nonnullMeterStats().values().iterator().next();
@Override
public void testStoreStatistics() {
- final org.opendaylight.yang.gen.v1.urn
- .opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats stat =
- mock(org.opendaylight.yang.gen.v1.urn
- .opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats.class);
- when(stat.getMeterId()).thenReturn(new MeterId(METER_NO));
-
- final Map<MeterStatsKey, org.opendaylight.yang.gen.v1.urn
- .opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats>
- stats = Collections.singletonMap(stat.key(), stat);
- final GetMeterStatisticsOutput output = mock(GetMeterStatisticsOutput.class);
- when(output.nonnullMeterStats()).thenReturn(stats);
-
- multipartWriterProvider.lookup(MultipartType.OFPMPMETER).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPMETER).orElseThrow()
+ .write(new GetMeterStatisticsOutputBuilder()
+ .setMeterStats(BindingMap.of(new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918
+ .meter.statistics.reply.MeterStatsBuilder()
+ .setMeterId(new MeterId(METER_NO))
+ .build()))
+ .build(), true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
-import java.util.Map;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.multipart.reply.multipart.reply.body.MultipartReplyPortStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.multipart.request.multipart.request.body.MultipartRequestPortStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMapBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMapKey;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
@Override
public void testBuildRequestBody() {
- final GetNodeConnectorStatisticsInput input = mock(GetNodeConnectorStatisticsInput.class);
-
- lenient().when(input.getNode()).thenReturn(createNodeRef(NODE_ID));
- when(input.getNodeConnectorId()).thenReturn(nodeConnectorId);
-
- final MultipartRequestPortStats body = (MultipartRequestPortStats) ((MultipartRequest)service
- .buildRequest(new Xid(Uint32.valueOf(42L)), input))
+ final var body = (MultipartRequestPortStats) ((MultipartRequest)service
+ .buildRequest(new Xid(Uint32.valueOf(42L)), new GetNodeConnectorStatisticsInputBuilder()
+ .setNode(createNodeRef(NODE_ID))
+ .setNodeConnectorId(nodeConnectorId)
+ .build()))
.getMultipartRequestBody();
assertEquals(nodeConnectorId, body.getNodeConnectorId());
@Override
public void testBuildReply() {
- final NodeConnectorStatisticsAndPortNumberMap portStat = new NodeConnectorStatisticsAndPortNumberMapBuilder()
- .setNodeConnectorId(nodeConnectorId)
- .build();
-
- final MultipartReply reply = new MultipartReplyBuilder()
- .setMultipartReplyBody(new MultipartReplyPortStatsBuilder()
- .setNodeConnectorStatisticsAndPortNumberMap(BindingMap.of(portStat))
- .build())
- .build();
-
- final List<MultipartReply> input = Collections.singletonList(reply);
- final GetNodeConnectorStatisticsOutput output = service.buildReply(input, true);
+ final var output = service.buildReply(List.of(new MultipartReplyBuilder()
+ .setMultipartReplyBody(new MultipartReplyPortStatsBuilder()
+ .setNodeConnectorStatisticsAndPortNumberMap(BindingMap.of(
+ new NodeConnectorStatisticsAndPortNumberMapBuilder().setNodeConnectorId(nodeConnectorId).build()))
+ .build())
+ .build()), true);
assertTrue(output.nonnullNodeConnectorStatisticsAndPortNumberMap().size() > 0);
- final NodeConnectorStatisticsAndPortNumberMap stats =
- output.nonnullNodeConnectorStatisticsAndPortNumberMap().values().iterator().next();
+ final var stats = output.nonnullNodeConnectorStatisticsAndPortNumberMap().values().iterator().next();
assertEquals(stats.getNodeConnectorId(), nodeConnectorId);
}
@Override
public void testStoreStatistics() {
- final NodeConnectorStatisticsAndPortNumberMap stat = mock(NodeConnectorStatisticsAndPortNumberMap.class);
- when(stat.getNodeConnectorId()).thenReturn(nodeConnectorId);
-
- final Map<NodeConnectorStatisticsAndPortNumberMapKey, NodeConnectorStatisticsAndPortNumberMap> stats
- = Collections.singletonMap(stat.key(), stat);
- final GetNodeConnectorStatisticsOutput output = mock(GetNodeConnectorStatisticsOutput.class);
- when(output.nonnullNodeConnectorStatisticsAndPortNumberMap()).thenReturn(stats);
-
- multipartWriterProvider.lookup(MultipartType.OFPMPPORTSTATS).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPPORTSTATS).orElseThrow()
+ .write(new GetNodeConnectorStatisticsOutputBuilder()
+ .setNodeConnectorStatisticsAndPortNumberMap(BindingMap.of(
+ new NodeConnectorStatisticsAndPortNumberMapBuilder().setNodeConnectorId(nodeConnectorId).build()))
+ .build(), true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMapBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMapKey;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
final MultipartReply reply = new MultipartReplyBuilder()
.setMultipartReplyBody(new MultipartReplyQueueStatsBuilder()
- .setQueueIdAndStatisticsMap(Collections.singletonMap(queueStats.key(), queueStats))
+ .setQueueIdAndStatisticsMap(BindingMap.of(queueStats))
.build())
.build();
- final List<MultipartReply> input = Collections.singletonList(reply);
+ final List<MultipartReply> input = List.of(reply);
final GetQueueStatisticsOutput output = service.buildReply(input, true);
assertTrue(output.nonnullQueueIdAndStatisticsMap().size() > 0);
new QueueIdAndStatisticsMapKey(new NodeConnectorId("1"), new QueueId(QUEUE_NO)));
final GetQueueStatisticsOutput output = mock(GetQueueStatisticsOutput.class);
- Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> stats = Collections.singletonMap(map.key(), map);
+ Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> stats = BindingMap.of(map);
when(output.nonnullQueueIdAndStatisticsMap()).thenReturn(stats);
- multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
when(map.key()).thenReturn(
new QueueIdAndStatisticsMapKey(new NodeConnectorId("openflow:1:1"), new QueueId(QUEUE_NO)));
- final Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> maps = Collections.singletonMap(map.key(), map);
+ final Map<QueueIdAndStatisticsMapKey, QueueIdAndStatisticsMap> maps = BindingMap.of(map);
final GetQueueStatisticsOutput output = mock(GetQueueStatisticsOutput.class);
when(output.nonnullQueueIdAndStatisticsMap()).thenReturn(maps);
- multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).get().write(output, true);
+ multipartWriterProvider.lookup(MultipartType.OFPMPQUEUE).orElseThrow().write(output, true);
verify(deviceContext).writeToTransactionWithParentsSlow(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
}
}
Code Review / openflowplugin.git / commitdiff