package io.fd.hc2vpp.acl.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.acl.util.AclContextManager;
import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
package io.fd.hc2vpp.acl.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.acl.util.AclContextManager;
import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
import io.fd.hc2vpp.acl.util.ace.AceConverter;
package io.fd.hc2vpp.acl.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.acl.util.AclContextManager;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
package io.fd.hc2vpp.acl.read;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Streams;
import io.fd.hc2vpp.acl.util.AclContextManager;
package io.fd.hc2vpp.acl.read;
-import com.google.common.base.Optional;
import com.google.common.collect.Streams;
import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.jvpp.acl.dto.MacipAclInterfaceListDump;
import io.fd.jvpp.acl.future.FutureJVppAclFacade;
import java.util.Collection;
+import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Nonnull;
final Optional<MacipAclInterfaceListDetailsReplyDump> macIpIfcDumpReply =
macipAclInterfaceListDumpManager.getDump(instanceIdentifier, readContext.getModificationCache());
- Stream<InterfaceKey> stdAclIfcKeys = stdIfcDumpReply.asSet().stream()
+ Stream<InterfaceKey> stdAclIfcKeys =
+ stdIfcDumpReply.map(Collections::singleton).orElse(Collections.emptySet()).stream()
.map(dump -> dump.aclInterfaceListDetails)
.flatMap(Collection::stream)
.filter(aclInterfaceListDetails -> aclInterfaceListDetails.acls.length != 0)
.map(details -> getInterfaceKey(readContext, details.swIfIndex));
- Stream<InterfaceKey> macIpAclIfcKeys = macIpIfcDumpReply.asSet().stream()
+ Stream<InterfaceKey> macIpAclIfcKeys =
+ macIpIfcDumpReply.map(Collections::singleton).orElse(Collections.emptySet()).stream()
.map(dump -> dump.macipAclInterfaceListDetails)
.flatMap(Collection::stream)
.map(details -> getInterfaceKey(readContext, details.swIfIndex));
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.util.RWUtils;
import java.util.ArrayList;
import static com.google.common.base.Preconditions.checkState;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.acl.AclIIds;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesStateBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.acl.AclIIds;
import io.fd.hc2vpp.acl.AclTestSchemaContext;
import io.fd.hc2vpp.acl.util.AclContextManager;
@Test
public void deleteCurrentAttributesIcmpIpv4(@InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json")
Acls standardAcls) throws Exception {
- when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty());
final int aclIndex = 4;
when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex);
aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext);
public void deleteCurrentAttributesIcmpIpv6(
@InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp-v6.json")
Acls standardAcls) throws Exception {
- when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty());
final int aclIndex = 4;
when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex);
aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext);
@Test
public void deleteCurrentAttributesTcp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-tcp.json")
Acls standardAcls) throws Exception {
- when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty());
final int aclIndex = 4;
when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex);
aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext);
@Test
public void deleteCurrentAttributesUdp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-udp.json")
Acls standardAcls) throws Exception {
- when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty());
final int aclIndex = 4;
when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex);
aclCustomizer.deleteCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext);
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.acl.AclIIds;
import io.fd.hc2vpp.acl.AclTestSchemaContext;
import io.fd.honeycomb.test.tools.HoneycombTestRunner;
package io.fd.hc2vpp.dhcp.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.primitives.UnsignedInts;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class DhcpModuleTest {
public List<TableKey> getAllIds(@Nonnull final InstanceIdentifier<Table> instanceIdentifier,
@Nonnull final ReadContext readContext) throws ReadFailedException {
return Stream.concat(ipv4DumpManager.getDump(instanceIdentifier, readContext.getModificationCache())
- .or(new IpFibDetailsReplyDump())
+ .orElse(new IpFibDetailsReplyDump())
.ipFibDetails.stream()
.filter(ipFibDetails -> ipFibDetails.tableId >= 0)
.map(ipFibDetails -> new TableKey(Ipv4.class, new VniReference((long) ipFibDetails.tableId)))
.distinct(),
ipv6DumpManager.getDump(instanceIdentifier, readContext.getModificationCache())
- .or(new Ip6FibDetailsReplyDump())
+ .orElse(new Ip6FibDetailsReplyDump())
.ip6FibDetails.stream()
.filter(ip6FibDetails -> ip6FibDetails.tableId >= 0)
.map(ipFibDetails -> new TableKey(Ipv6.class, new VniReference((long) ipFibDetails.tableId))))
if (tableKey.getAddressFamily().equals(Ipv4.class)) {
ipv4DumpManager.getDump(instanceIdentifier, readContext.getModificationCache())
- .or(new IpFibDetailsReplyDump())
+ .orElse(new IpFibDetailsReplyDump())
.ipFibDetails.stream()
.filter(ipFibDetails -> ipFibDetails.tableId == tableKey.getTableId().getValue().intValue())
.findFirst().ifPresent(
} else {
ipv6DumpManager.getDump(instanceIdentifier, readContext.getModificationCache())
- .or(new Ip6FibDetailsReplyDump())
+ .orElse(new Ip6FibDetailsReplyDump())
.ip6FibDetails.stream()
.filter(ipFibDetails -> ipFibDetails.tableId == tableKey.getTableId().getValue().intValue())
.findFirst().ifPresent(
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class FibManagementModuleTest {
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class VppIoamModuleTest {
package io.fd.hc2vpp.ipsec.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.Ipv6Translator;
package io.fd.hc2vpp.ipsec.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.Ipv6Translator;
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-impl</artifactId>
+ <version>${odl.yangtools.version}</version>
+ <scope>test</scope>
+ </dependency>
</dependencies>
</project>
\ No newline at end of file
package io.fd.hc2vpp.l3.read.ipv4;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Dynamic;
import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Static;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import io.fd.hc2vpp.l3.utils.ip.read.IpNeighbourReader;
package io.fd.hc2vpp.l3.read.ipv4.subinterface;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import io.fd.hc2vpp.l3.utils.ip.read.IpAddressReader;
package io.fd.hc2vpp.l3.read.ipv4.subinterface;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import io.fd.hc2vpp.l3.utils.ip.read.IpNeighbourReader;
package io.fd.hc2vpp.l3.read.ipv6;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import io.fd.hc2vpp.l3.utils.ip.read.IpAddressReader;
import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Dynamic;
import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Static;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import io.fd.hc2vpp.l3.utils.ip.read.IpNeighbourReader;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.Ipv6Translator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
package io.fd.hc2vpp.l3.read.ipv6.subinterface;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import io.fd.hc2vpp.l3.utils.ip.read.IpAddressReader;
package io.fd.hc2vpp.l3.read.ipv6.subinterface;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.l3.utils.ip.read.IfaceDumpFilter;
import io.fd.hc2vpp.l3.utils.ip.read.IpNeighbourReader;
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
.filter(singleDetail -> ip.equals(arrayToIpv4AddressNoZone(singleDetail.ip)))
.collect(RWUtils.singleItemCollector()));
}
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
.filter(singleDetail -> ip.equals(arrayToIpv6AddressNoZone(singleDetail.ip)))
.collect(RWUtils.singleItemCollector()));
}
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.util.RWUtils;
import java.util.stream.Collector;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
import io.fd.honeycomb.translate.util.read.BindingBrokerReader;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.eid.mapping.context.rev160801.Contexts;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.eid.mapping.context.rev160801.ContextsBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.inject.Provider;
import com.google.inject.name.Named;
import io.fd.honeycomb.translate.read.ReaderFactory;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class ContextsReaderFactoryProvider implements Provider<ReaderFactory> {
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.lisp.translate.util.EidTranslator;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.util.RWUtils;
import static java.lang.String.format;
-import com.google.common.base.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Nonnull;
private Stream<Integer> activeVnis(final InstanceIdentifier<GpeEntry> id,
final ModificationCache cache) throws ReadFailedException {
- final int[] vnis = activeVnisDumpManager.getDump(id, cache).or(() -> {
+ final int[] vnis = activeVnisDumpManager.getDump(id, cache).orElseGet(() -> {
final GpeFwdEntryVnisGetReply reply = new GpeFwdEntryVnisGetReply();
reply.vnis = new int[0];
return reply;
final ModificationCache modificationCache,
final DumpCacheManager<GpeNativeFwdRpathsGetReply, Integer> dumpCacheManager)
throws ReadFailedException {
- return dumpCacheManager.getDump(id, modificationCache, 1).or(DEFAULT_DUMP);
+ return dumpCacheManager.getDump(id, modificationCache, 1).orElse(DEFAULT_DUMP);
}
private static GpeNativeFwdRpathsGetReply v6Dump(final @Nonnull InstanceIdentifier<?> id,
final ModificationCache modificationCache,
final DumpCacheManager<GpeNativeFwdRpathsGetReply, Integer> dumpCacheManager)
throws ReadFailedException {
- return dumpCacheManager.getDump(id, modificationCache, 0).or(DEFAULT_DUMP);
+ return dumpCacheManager.getDump(id, modificationCache, 0).orElse(DEFAULT_DUMP);
}
}
private Stream<Integer> v4FibsStream(final InstanceIdentifier<NativeForwardPathsTable> id,
final ReadContext ctx) throws ReadFailedException {
- return dumpCacheManagerV4.getDump(id, ctx.getModificationCache()).or(DEFAULT_REPLY_V4)
+ return dumpCacheManagerV4.getDump(id, ctx.getModificationCache()).orElse(DEFAULT_REPLY_V4)
.ipFibDetails.stream()
.map(ipFibDetails -> ipFibDetails.tableId);
}
private Stream<Integer> v6FibsStream(final InstanceIdentifier<NativeForwardPathsTable> id,
final ReadContext ctx) throws ReadFailedException {
- return dumpCacheManagerV6.getDump(id, ctx.getModificationCache()).or(DEFAULT_REPLY_V6)
+ return dumpCacheManagerV6.getDump(id, ctx.getModificationCache()).orElse(DEFAULT_REPLY_V6)
.ip6FibDetails.stream()
.map(ip6FibDetails -> ip6FibDetails.tableId);
}
@Override
public void checkGpeEnabledBefore(@Nonnull final WriteContext writeContext) {
- checkState(writeContext.readBefore(GPE_FEATURE_CONFIG_ID).or(DISABLED_GPE).isEnable(),
+ checkState(writeContext.readBefore(GPE_FEATURE_CONFIG_ID).orElse(DISABLED_GPE).isEnable(),
"Gpe feature is disabled");
}
@Override
public void checkGpeEnabledAfter(@Nonnull final WriteContext writeContext) {
- checkState(writeContext.readAfter(GPE_FEATURE_CONFIG_ID).or(DISABLED_GPE).isEnable(),
+ checkState(writeContext.readAfter(GPE_FEATURE_CONFIG_ID).orElse(DISABLED_GPE).isEnable(),
"Gpe feature is disabled");
}
try {
return byteToBoolean(
dumpCacheManager.getDump(GPE_FEATURE_STATE_ID, readContext.getModificationCache())
- .or(DEFAULT_REPLY).gpeStatus);
+ .orElse(DEFAULT_REPLY).gpeStatus);
} catch (ReadFailedException e) {
throw new IllegalStateException("Unable to read Gpe feature status", e);
}
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.lisp.context.util.AdjacenciesMappingContext;
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.lisp.translate.read.dump.executor.params.SubtableDumpParams;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
package io.fd.hc2vpp.lisp.translate.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
package io.fd.hc2vpp.lisp.translate.read;
-import com.google.common.base.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.jvpp.core.dto.ShowOneStatus;
import io.fd.jvpp.core.dto.ShowOneStatusReply;
import io.fd.jvpp.core.future.FutureJVppCore;
+import java.util.Optional;
import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.Lisp;
import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams.MappingsDumpParamsBuilder;
import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams.QuantityType;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.lisp.context.util.EidMappingContext;
package io.fd.hc2vpp.lisp.translate.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
import io.fd.hc2vpp.lisp.translate.read.trait.LocatorSetReader;
package io.fd.hc2vpp.lisp.translate.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
package io.fd.hc2vpp.lisp.translate.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.lisp.translate.service.LispStateCheckService;
import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams.FilterType;
import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams.MappingsDumpParamsBuilder;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.jvpp.core.future.FutureJVppCore;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.MapReplyAction;
reply = locatorsDumpManager.getDump(locatorIfaceIdentifier, cache,
new LocatorDumpParamsBuilder().setLocatorSetIndex(details.locatorSetIndex).build());
- bindPositiveMapping(builder, reply.or(new OneLocatorDetailsReplyDump()));
+ bindPositiveMapping(builder, reply.orElse(new OneLocatorDetailsReplyDump()));
}
}
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.lisp.translate.service.LispStateCheckService;
import io.fd.hc2vpp.lisp.translate.util.CheckedLispCustomizer;
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.lisp.translate.read.dump.executor.params.SubtableDumpParams;
import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
public void checkLispEnabledBefore(@Nonnull final WriteContext ctx) {
// no need to dump here, can be read directly from context
checkState(ctx.readBefore(InstanceIdentifier.create(Lisp.class))
- .or(STATIC_LISP_INSTANCE).isEnable(), "Lisp feature not enabled");
+ .orElse(STATIC_LISP_INSTANCE).isEnable(), "Lisp feature not enabled");
}
@Override
public void checkLispEnabledAfter(@Nonnull final WriteContext ctx) {
// no need to dump here, can be read directly from context
checkState(ctx.readAfter(InstanceIdentifier.create(Lisp.class))
- .or(STATIC_LISP_INSTANCE).isEnable(), "Lisp feature not enabled");
+ .orElse(STATIC_LISP_INSTANCE).isEnable(), "Lisp feature not enabled");
}
@Override
// in this case it must be dumped
try {
return byteToBoolean(dumpManager.getDump(IDENTIFIER, ctx.getModificationCache())
- .or(DEFAULT_REPLY).featureStatus);
+ .orElse(DEFAULT_REPLY).featureStatus);
} catch (ReadFailedException e) {
throw new IllegalStateException("Unable to read Lisp Feature status", e);
}
import static com.google.common.base.Preconditions.checkState;
import static java.nio.charset.StandardCharsets.UTF_8;
-import com.google.common.base.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.common.translate.util.ReferenceCheck;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.DpSubtableGrouping;
if (eidTableData.isPresent()) {
// due to non-functional LeafRefValidation, it must be checked like this
final List<VniTable> vniTables =
- Optional.fromNullable(eidTableData.get().getVniTable()).or(Collections.emptyList());
+ Optional.ofNullable(eidTableData.get().getVniTable()).orElse(Collections.emptyList());
checkReferenceExist(id, vrfReferences(vniTables, locatorSetName));
checkReferenceExist(id, bdReferences(vniTables, locatorSetName));
}
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.lisp.translate.service.LispStateCheckService;
import io.fd.hc2vpp.lisp.translate.util.CheckedLispCustomizer;
import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class LispModuleTest {
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableSet;
import io.fd.honeycomb.test.tools.HoneycombTestRunner;
import io.fd.honeycomb.test.tools.annotations.InjectTestData;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.common.test.read.InitializingReaderCustomizerTest;
import io.fd.hc2vpp.common.test.util.NamingContextHelper;
when(mappingContext.read(namingContextId.child(Mappings.class)))
.thenReturn(Optional.of(new MappingsBuilder().setMapping(Arrays.asList(loc1Data, loc2Data)).build()));
- when(mappingContext.read(loc1Key)).thenReturn(Optional.absent())
+ when(mappingContext.read(loc1Key)).thenReturn(Optional.empty())
.thenReturn(Optional.of(loc1Data)).thenReturn(Optional.of(loc1Data));
- when(mappingContext.read(loc2Key)).thenReturn(Optional.absent())
+ when(mappingContext.read(loc2Key)).thenReturn(Optional.empty())
.thenReturn(Optional.of(loc2Data)).thenReturn(Optional.of(loc2Data));
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.test.util.FutureProducer;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.read.ReadContext;
@Test(expected = IllegalStateException.class)
public void testCheckLispEnabledBeforeNoConfig() throws Exception {
- when(writeContext.readBefore(InstanceIdentifier.create(Lisp.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(InstanceIdentifier.create(Lisp.class))).thenReturn(Optional.empty());
impl.checkLispEnabledBefore(writeContext);
}
@Test(expected = IllegalStateException.class)
public void testCheckLispEnabledAfterNoConfig() throws Exception {
- when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))).thenReturn(Optional.empty());
impl.checkLispEnabledAfter(writeContext);
}
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.jvpp.core.dto.OneLocatorSetDetailsReplyDump;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
+import java.util.NoSuchElementException;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
lispStateCheckService);
}
- @Test(expected = NullPointerException.class)
+ @Test(expected = NoSuchElementException.class)
public void testWriteCurrentAttributesNullData() throws WriteFailedException {
customizer.writeCurrentAttributes(null, null, writeContext);
}
- @Test(expected = NullPointerException.class)
+ @Test(expected = NoSuchElementException.class)
public void testWriteCurrentAttributesBadData() throws WriteFailedException {
customizer.writeCurrentAttributes(null, mock(LocatorSet.class), writeContext);
}
@Test
public void testDeleteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
- when(writeContext.readAfter(EID_TABLE_ID)).thenReturn(Optional.absent());
+ when(writeContext.readAfter(EID_TABLE_ID)).thenReturn(Optional.empty());
verifySuccessfullDelete(LOCATOR_SET_TO_DELETE);
}
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.write.WriteFailedException;
import org.junit.Before;
import org.junit.Test;
}
private void whenReadBeforeReturnInvalid() {
- when(writeContext.readBefore(validId)).thenReturn(Optional.absent());
+ when(writeContext.readBefore(validId)).thenReturn(Optional.empty());
}
private void whenReadAfterReturnValid() {
}
private void whenReadAfterReturnInvalid() {
- when(writeContext.readAfter(validId)).thenReturn(Optional.absent());
+ when(writeContext.readAfter(validId)).thenReturn(Optional.empty());
}
}
import static com.google.common.base.Preconditions.checkNotNull;
import static org.mockito.Mockito.doReturn;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.MappingContext;
import java.util.List;
final List<Mapping> list = Common.getMappingList(mappingContext, iid);
doReturn(Optional.of(new MappingsBuilder().setMapping(list).build())).when(mappingContext).read(iid);
- doReturn(Optional.absent()).when(mappingContext).read(mappingIid(name, namingContextName));
+ doReturn(Optional.empty()).when(mappingContext).read(mappingIid(name, namingContextName));
}
final class Common {
import static org.mockito.Mockito.doReturn;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.MappingContext;
import java.util.List;
final List<Mapping> list = Common.getMappingList(mappingContext, iid);
doReturn(Optional.of(new MappingsBuilder().setMapping(list).build())).when(mappingContext).read(iid);
- doReturn(Optional.absent()).when(mappingContext).read(mappingIid(new MappingId(name), namingContextName));
+ doReturn(Optional.empty()).when(mappingContext).read(mappingIid(new MappingId(name), namingContextName));
}
final class Common {
ExternalIpPoolCustomizer(@Nonnull final FutureJVppNatFacade jvppNat) {
checkNotNull(jvppNat, "jvppNat should not be null");
this.nat44DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<Nat44AddressDetailsReplyDump, Void>()
- .withExecutor((id, params) -> getReplyForRead(jvppNat.nat44AddressDump(new Nat44AddressDump()).toCompletableFuture(), id))
+ .withExecutor((id, params) -> getReplyForRead(
+ jvppNat.nat44AddressDump(new Nat44AddressDump()).toCompletableFuture(), id))
.acceptOnly(Nat44AddressDetailsReplyDump.class)
.build();
this.nat64DumpMgr = new DumpCacheManager.DumpCacheManagerBuilder<Nat64PoolAddrDetailsReplyDump, Void>()
- .withExecutor((id, params) -> getReplyForRead(jvppNat.nat64PoolAddrDump(new Nat64PoolAddrDump()).toCompletableFuture(), id))
+ .withExecutor((id, params) -> getReplyForRead(
+ jvppNat.nat64PoolAddrDump(new Nat64PoolAddrDump()).toCompletableFuture(), id))
.acceptOnly(Nat64PoolAddrDetailsReplyDump.class)
.build();
}
final Long poolId = id.firstKeyOf(ExternalIpAddressPool.class).getPoolId();
final List<Nat44AddressDetails> nat44Details =
nat44DumpMgr.getDump(id, ctx.getModificationCache())
- .or(new Nat44AddressDetailsReplyDump()).nat44AddressDetails;
+ .orElse(new Nat44AddressDetailsReplyDump()).nat44AddressDetails;
final int nat44PoolCount = nat44Details.size();
// Uses ID<->address mapping as defined by getAllIds (nat44 mappings go before nat64):
setPoolType(builder, NatPoolType.Nat44);
} else {
final List<Nat64PoolAddrDetails> nat64Details = nat64DumpMgr.getDump(id, ctx.getModificationCache())
- .or(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails;
+ .orElse(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails;
final int nat64PoolCount = nat64Details.size();
final int nat64PoolPosition = Math.toIntExact(poolId) - nat44PoolCount;
if (nat64PoolPosition < nat64PoolCount) {
// That's why the write and read is not symmetrical in terms of data structure, instead,
// this customizer also returns every single address as a 32 prefix and assigns an artificial key to them
- long addressCount = nat44DumpMgr.getDump(id, ctx.getModificationCache())
- .or(new Nat44AddressDetailsReplyDump()).nat44AddressDetails.stream()
- .count();
+ long addressCount = (long) nat44DumpMgr.getDump(id, ctx.getModificationCache())
+ .orElse(new Nat44AddressDetailsReplyDump()).nat44AddressDetails.size();
// The ietf-nat model groups address pools for Nat44 and Nat64 under the same list,
// but VPP uses different APIs, so we need an other dump:
- addressCount += nat64DumpMgr.getDump(id, ctx.getModificationCache())
- .or(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails.stream()
- .count();
+ addressCount += (long) nat64DumpMgr.getDump(id, ctx.getModificationCache())
+ .orElse(new Nat64PoolAddrDetailsReplyDump()).nat64PoolAddrDetails.size();
final List<ExternalIpAddressPoolKey> ids = LongStream.range(0, addressCount)
.mapToObj(ExternalIpAddressPoolKey::new)
final int natInstanceId = id.firstKeyOf(Instance.class).getId().intValue();
final List<Nat44StaticMappingDetails> nat44Details =
nat44DumpManager.getDump(id, ctx.getModificationCache())
- .or(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails;
+ .orElse(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails;
final Optional<Nat44StaticMappingDetails> nat44StaticMappingDetails =
mappingEntryContext.findDetailsNat44(nat44Details, natInstanceId, idx, ctx.getMappingContext());
} else {
final List<Nat64BibDetails> nat64Details =
nat64DumpManager.getDump(id, ctx.getModificationCache())
- .or(new Nat64BibDetailsReplyDump()).nat64BibDetails;
+ .orElse(new Nat64BibDetailsReplyDump()).nat64BibDetails;
final Optional<Nat64BibDetails> nat64StaticMappingDetails =
mappingEntryContext.findDetailsNat64(nat64Details, natInstanceId, idx, ctx.getMappingContext());
final List<MappingEntryKey> entryKeys =
nat44DumpManager.getDump(id, context.getModificationCache())
- .or(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream()
+ .orElse(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream()
.filter(detail -> natInstanceId == detail.vrfId)
.map(detail -> mappingEntryContext
.getStoredOrArtificialIndex(natInstanceId, detail, context.getMappingContext()))
final List<MappingEntryKey> nat64Keys =
nat64DumpManager.getDump(id, context.getModificationCache())
- .or(new Nat64BibDetailsReplyDump()).nat64BibDetails.stream()
+ .orElse(new Nat64BibDetailsReplyDump()).nat64BibDetails.stream()
.filter(detail -> natInstanceId == detail.vrfId)
.map(detail -> mappingEntryContext
.getStoredOrArtificialIndex(natInstanceId, detail, context.getMappingContext()))
// Find the nat instance IDs (vrf-ids) by listing all static mappings and their VRF assignment
final List<InstanceKey> vrfIds = Stream.concat(
nat44DumpManager.getDump(id, context.getModificationCache())
- .or(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream()
+ .orElse(new Nat44StaticMappingDetailsReplyDump()).nat44StaticMappingDetails.stream()
.map(detail -> detail.vrfId),
nat64DumpManager.getDump(id, context.getModificationCache())
- .or(new Nat64BibDetailsReplyDump()).nat64BibDetails.stream()
+ .orElse(new Nat64BibDetailsReplyDump()).nat64BibDetails.stream()
.map(detail -> detail.vrfId))
// V4 (nat44) and V6 (nat64) VRFs in VPP can have the same id. We store them under single nat instance,
// because the ietf-nat model does not require separate instances for nat44 and nat64 features.
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.jvpp.nat.dto.Nat64InterfaceDetailsReplyDump;
import io.fd.jvpp.nat.dto.Nat64InterfaceDump;
import io.fd.jvpp.nat.future.FutureJVppNatFacade;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yangtools.concepts.Builder;
final Optional<Nat44InterfaceDetailsReplyDump> dump =
preRoutingNat44DumpMgr.getDump(id, ctx.getModificationCache());
- dump.or(new Nat44InterfaceDetailsReplyDump()).nat44InterfaceDetails.stream()
+ dump.orElse(new Nat44InterfaceDetailsReplyDump()).nat44InterfaceDetails.stream()
.filter(natIfcDetail -> natIfcDetail.swIfIndex == index)
.filter(natIfcDetail -> isExpectedNatType(natIfcDetail.isInside))
.findAny()
final Optional<Nat64InterfaceDetailsReplyDump> dump =
preRoutingNat64DumpMgr.getDump(id, ctx.getModificationCache());
- dump.or(new Nat64InterfaceDetailsReplyDump()).nat64InterfaceDetails.stream()
+ dump.orElse(new Nat64InterfaceDetailsReplyDump()).nat64InterfaceDetails.stream()
.filter(natIfcDetail -> natIfcDetail.swIfIndex == index)
.filter(natIfcDetail -> isExpectedNatType(natIfcDetail.isInside))
.findAny()
final Optional<Nat44InterfaceOutputFeatureDetailsReplyDump> dump =
postRoutingNat44DumpMgr.getDump(id, ctx.getModificationCache());
- dump.or(new Nat44InterfaceOutputFeatureDetailsReplyDump()).nat44InterfaceOutputFeatureDetails
+ dump.orElse(new Nat44InterfaceOutputFeatureDetailsReplyDump()).nat44InterfaceOutputFeatureDetails
.stream()
.filter(natIfcDetail -> natIfcDetail.swIfIndex == index)
.filter(natIfcDetail -> isExpectedNatType(natIfcDetail.isInside))
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.Ipv6Translator;
import io.fd.honeycomb.translate.MappingContext;
@Nonnull final MappingContext mappingContext) {
// Find mapping entry for Index
final MappingEntry ctxMappingEntry = mappingContext.read(getTableId(natInstanceId))
- .transform(MappingTable::getMappingEntry)
- .or(Collections.emptyList())
+ .map(MappingTable::getMappingEntry)
+ .orElse(Collections.emptyList())
.stream()
.filter(entry -> entry.getIndex() == idx)
.findFirst()
@Nonnull final MappingContext mappingContext) {
// Find mapping entry for Index
final MappingEntry ctxMappingEntry = mappingContext.read(getTableId(natInstanceId))
- .transform(MappingTable::getMappingEntry)
- .or(Collections.emptyList())
+ .map(MappingTable::getMappingEntry)
+ .orElse(Collections.emptyList())
.stream()
.filter(entry -> entry.getIndex() == idx)
.findFirst()
@Nonnull final Nat44StaticMappingDetails details,
@Nonnull final MappingContext mappingContext) {
return mappingContext.read(getId(natInstanceId, entryToKey(details)))
- .transform(MappingEntry::getIndex)
- .or(() -> getArtificialId(details, natInstanceId, mappingContext));
+ .map(MappingEntry::getIndex)
+ .orElseGet(() -> getArtificialId(details, natInstanceId, mappingContext));
}
/**
@Nonnull final Nat64BibDetails details,
@Nonnull final MappingContext mappingContext) {
return mappingContext.read(getId(natInstanceId, entryToKey(details)))
- .transform(MappingEntry::getIndex)
- .or(() -> getArtificialId(details, natInstanceId, mappingContext));
+ .map(MappingEntry::getIndex)
+ .orElseGet(() -> getArtificialId(details, natInstanceId, mappingContext));
}
/**
public synchronized Optional<Long> getStoredIndex(final long natInstanceId,
@Nonnull final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev180628.nat.instances.instance.mapping.table.MappingEntry entry,
@Nonnull final MappingContext mappingContext) {
- return mappingContext.read(getId(natInstanceId, entryToKey(entry)))
- .transform(MappingEntry::getIndex);
+ return mappingContext.read(getId(natInstanceId, entryToKey(entry))).map(MappingEntry::getIndex);
}
private long getArtificialId(final Nat44StaticMappingDetails details, final Long natInstanceId,
private long findFreeIndex(final long natInstanceId, final MappingContext mappingContext) {
return mappingContext.read(getTableId(natInstanceId))
- .transform(MappingTable::getMappingEntry)
- .or(Collections.emptyList())
+ .map(MappingTable::getMappingEntry)
+ .orElse(Collections.emptyList())
.stream()
.map(MappingEntry::getIndex)
.max(Comparator.naturalOrder())
package io.fd.hc2vpp.nat.write;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.Ipv6Translator;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesStateBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Lists;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.honeycomb.translate.MappingContext;
@Test
public void testAdd() throws Exception {
- when(mappingCtx.read(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(mappingCtx.read(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final long natId = 7;
final long entryId = 99;
final MappingEntry entry = getEntry(natId, "192.168.1.5/32", "17.14.4.6/32");
final long entryId = 12;
final Nat44StaticMappingDetails details = getDetails(entryId, "192.168.1.5", "17.14.4.6");
final List<Nat44StaticMappingDetails> someDetails = Lists.newArrayList(details);
- when(mappingCtx.read(MappingEntryContext.getTableId(natId))).thenReturn(Optional.absent());
+ when(mappingCtx.read(MappingEntryContext.getTableId(natId))).thenReturn(Optional.empty());
ctx.findDetailsNat44(someDetails, natId, entryId, mappingCtx);
}
final MappingEntry newEntry = getEntry(newEntryId, "192.168.1.99/32", "17.14.4.99/32");
final Nat44StaticMappingDetails newDetails = getDetails(newEntryId, "192.168.1.99", "17.14.4.99");
when(mappingCtx.read(MappingEntryContext.getId(natId, MappingEntryContext.entryToKey(newEntry))))
- .thenReturn(Optional.absent());
+ .thenReturn(Optional.empty());
when(mappingCtx.read(MappingEntryContext.getTableId(natId)))
.thenReturn(Optional.of(new MappingTableBuilder()
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class VppNshModuleTest {
package io.fd.hc2vpp.samples.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
package io.fd.hc2vpp.routing.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.routing.trait.RouteMapper;
import io.fd.honeycomb.translate.ModificationCache;
package io.fd.hc2vpp.routing.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.MultiNamingContext;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.routing.RoutingConfiguration;
package io.fd.hc2vpp.routing.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.MultiNamingContext;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.routing.RoutingConfiguration;
package io.fd.hc2vpp.routing.write;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
package io.fd.hc2vpp.routing.write;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
package io.fd.hc2vpp.routing.write.trait;
import static com.google.common.base.Preconditions.checkArgument;
-import static org.apache.commons.lang3.StringUtils.isNotEmpty;
import com.google.common.collect.ImmutableSet.Builder;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
default boolean classifyTablePresent(final String classifyTableName,
final VppClassifierContextManager classifierContextManager,
final MappingContext mappingContext) {
- return isNotEmpty(classifyTableName) &&
+
+ return classifyTableName != null && !classifyTableName.isEmpty() &&
classifierContextManager.containsTable(classifyTableName, mappingContext);
}
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class RoutingModuleTest {
import static org.junit.Assert.fail;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.fib.management.FibManagementIIds;
when(writeContext.readAfter(vrfIidV6)).thenReturn(Optional.of(
new TableBuilder().withKey(keyV6).setAddressFamily(keyV6.getAddressFamily())
.setTableId(keyV6.getTableId()).setName("VRF-IPV6-1").build()));
- when(writeContext.readAfter(invalidVrfIidV4)).thenReturn(Optional.absent());
- when(writeContext.readAfter(invalidVrfIidV6)).thenReturn(Optional.absent());
+ when(writeContext.readAfter(invalidVrfIidV4)).thenReturn(Optional.empty());
+ when(writeContext.readAfter(invalidVrfIidV6)).thenReturn(Optional.empty());
}
@Test(expected = WriteFailedException.class)
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableList;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.fib.management.FibManagementIIds;
import static io.fd.hc2vpp.routing.helpers.InterfaceTestHelper.INTERFACE_INDEX;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableList;
import io.fd.hc2vpp.fib.management.FibManagementIIds;
import io.fd.hc2vpp.routing.Ipv6RouteData;
import static io.fd.hc2vpp.routing.helpers.InterfaceTestHelper.INTERFACE_NAME;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.MultiNamingContext;
import io.fd.hc2vpp.common.translate.util.NamingContext;
when(writeContext.readAfter(TABLE_V6_IID)).thenReturn(Optional.of(
new TableBuilder().withKey(IPV6_TABLE_KEY).setAddressFamily(Ipv6.class)
.setTableId(IPV6_TABLE_KEY.getTableId()).build()));
- when(writeContext.readAfter(INVALID_TABLE_V4_IID)).thenReturn(Optional.absent());
- when(writeContext.readAfter(INVALID_TABLE_V6_IID)).thenReturn(Optional.absent());
+ when(writeContext.readAfter(INVALID_TABLE_V4_IID)).thenReturn(Optional.empty());
+ when(writeContext.readAfter(INVALID_TABLE_V6_IID)).thenReturn(Optional.empty());
}
}
package io.fd.hc2vpp.samples.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
@Nonnull
public List<PolicyKey> readAllKeys(@Nonnull InstanceIdentifier<Policy> id, @Nonnull ReadContext ctx)
throws ReadFailedException {
- return dumpManager.getDump(id, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
+ return dumpManager.getDump(id, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
.map(srPoliciesDetails -> arrayToIpv6AddressNoZone(srPoliciesDetails.bsid.addr))
.map(bsid -> parsePolicyKey(ctx, bsid))
.collect(Collectors.toList());
Ipv6Address bsid =
policyCtx.getPolicyBsid(key.getColor(), key.getEndpoint().getIpv6Address(), ctx.getMappingContext());
- dumpManager.getDump(id, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
+ dumpManager.getDump(id, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
.filter(srPoliciesDetails -> arrayToIpv6AddressNoZone(srPoliciesDetails.bsid.addr).getValue()
.equals(bsid.getValue()))
.findFirst()
public List<NamedSegmentListKey> readNamedSegmentListKeys(final InstanceIdentifier<NamedSegmentList> id,
final ReadContext ctx) throws ReadFailedException {
- return dumpManager.getDump(id, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
+ return dumpManager.getDump(id, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
.map(srPoliciesDetails -> {
String bsid = arrayToIpv6AddressNoZone(srPoliciesDetails.bsid.addr).getValue();
return Arrays.stream(srPoliciesDetails.sidLists).map(srv6SidList -> srv6SidList.weight)
Preconditions.checkNotNull(bsid, "Weight/Bsid not resolved for Iid: {}", id);
builder.setSegments(new SegmentsBuilder().build());
- dumpManager.getDump(id, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
+ dumpManager.getDump(id, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srPoliciesDetails.stream()
.filter(srPoliciesDetails -> arrayToIpv6AddressNoZone(srPoliciesDetails.bsid.addr).getValue()
.equals(bsid))
.forEach(srPoliciesDetails -> Arrays.stream(srPoliciesDetails.sidLists)
"Identifier does not have %s ", LocatorKey.class);
String locator = key.getName();
- return dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+ return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails
.stream()
.filter(detail -> arrayToIpv6AddressNoZone(detail.addr.addr).getValue().contains(locator))
.map(srLocalsidsDetails -> extractOpCode(arrayToIpv6AddressNoZone(srLocalsidsDetails.addr.addr),
Ipv6Address sidAddress =
parseSrv6SidAddress(locator.getValue(), locLength.toString(), sidKey.getOpcode().getValue());
- dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+ dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails
.stream()
.filter(detail -> Arrays.equals(detail.addr.addr, ipv6AddressNoZoneToArray(sidAddress)))
.findFirst()
public List<LocatorKey> readAllKeys(@Nonnull final InstanceIdentifier<Locator> identifier,
@Nonnull final ReadContext ctx)
throws ReadFailedException {
- return dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+ return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails
.stream()
.map(srLocalsidsDetails -> extractLocator(arrayToIpv6AddressNoZone(srLocalsidsDetails.addr.addr),
ctx.getMappingContext(), null).getValue())
"Identifier does not have %s ", LocatorKey.class);
String locator = key.getName();
- dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+ dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails
.stream()
.filter(detail -> arrayToIpv6AddressNoZone(detail.addr.addr).getValue().contains(locator))
.findFirst()
@Nonnull
public List<InterfaceKey> readAllKeys(@Nonnull InstanceIdentifier<Interface> identifier, @Nonnull ReadContext ctx)
throws ReadFailedException {
- return dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY)
+ return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY)
.srSteeringPolDetails.stream()
.filter(srSteeringPolDetails -> ((int) srSteeringPolDetails.trafficType) == L2_TRAFFIC_TYPE)
.map(srSteeringPolDetails -> srSteeringPolDetails.swIfIndex)
ifcNamingContext.getIndex(identifier.firstKeyOf(Interface.class).getInputInterface(),
ctx.getMappingContext());
- dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY)
+ dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY)
.srSteeringPolDetails.stream()
.filter(srSteeringPolDetails -> ((int) srSteeringPolDetails.trafficType) == L2_TRAFFIC_TYPE)
.filter(srSteeringPolDetails -> srSteeringPolDetails.swIfIndex == index)
@Nonnull
public List<PrefixKey> readAllKeys(@Nonnull InstanceIdentifier<Prefix> identifier, @Nonnull ReadContext ctx)
throws ReadFailedException {
- return dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY)
+ return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY)
.srSteeringPolDetails.stream()
.filter(
srSteeringPolDetails -> ((int) srSteeringPolDetails.trafficType) !=
public List<IpPrefix> readAllIpPrefixes(@Nonnull InstanceIdentifier<Prefixes> identifier, @Nonnull ReadContext ctx)
throws ReadFailedException {
- return dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY)
+ return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY)
.srSteeringPolDetails.stream()
.filter(
srSteeringPolDetails -> ((int) srSteeringPolDetails.trafficType) !=
@Nonnull PrefixBuilder builder) throws ReadFailedException {
checkValid();
PrefixKey key = identifier.firstKeyOf(Prefix.class);
- dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY)
+ dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY)
.srSteeringPolDetails.stream()
.filter(
srSteeringPolDetails -> ((int) srSteeringPolDetails.trafficType) !=
package io.fd.hc2vpp.srv6.util;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import java.util.concurrent.atomic.AtomicLong;
import javax.annotation.Nonnull;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.ThreadSafe;
package io.fd.hc2vpp.srv6.util;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.ThreadSafe;
package io.fd.hc2vpp.srv6.util;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.util.RWUtils;
import io.fd.honeycomb.translate.write.WriteContext;
import javax.annotation.Nonnull;
List<SidList> sidLists = new ArrayList<>();
segmentLists.forEach(segmentList -> {
- com.google.common.base.Optional<NamedSegmentList> namedSegmentListOptional = writeContext.readAfter(
+ java.util.Optional<NamedSegmentList> namedSegmentListOptional = writeContext.readAfter(
Srv6PolicyIIds.SR_TE_NSLS.child(NamedSegmentList.class,
new NamedSegmentListKey(segmentList.getName())));
package io.fd.hc2vpp.srv6.write.sid;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import com.googlecode.ipv6.IPv6NetworkMask;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.routing.rev180313.RoutingBuilder;
public class Srv6ModuleTest {
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
import io.fd.honeycomb.translate.MappingContext;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
import io.fd.honeycomb.translate.MappingContext;
import org.junit.Assert;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.srv6.Srv6PolicyIIds;
import io.fd.honeycomb.test.tools.annotations.InjectTestData;
import org.junit.Assert;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.fib.management.FibManagementIIds;
import io.fd.hc2vpp.srv6.util.JvppRequestTest;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.fib.management.FibManagementIIds;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
import io.fd.honeycomb.translate.write.WriteFailedException;
import org.junit.Before;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.AddressTranslator;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.srv6.Srv6PolicyIIds;
import io.fd.hc2vpp.srv6.util.JvppRequestTest;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.srv6.Srv6PolicyIIds;
import io.fd.hc2vpp.srv6.util.JvppRequestTest;
package io.fd.hc2vpp.v3po;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.inject.Inject;
import com.google.inject.name.Named;
import io.fd.honeycomb.translate.MappingContext;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.context.rev160909.DisabledInterfaces;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.context.rev160909.DisabledInterfacesBuilder;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.v3po.context.rev160909.disabled.interfaces.DisabledInterfaceIndex;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
import static com.google.common.base.Preconditions.checkState;
import static io.fd.hc2vpp.v3po.util.SubInterfaceUtils.subInterfaceFullNameConfig;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
}
final AfPacketDetailsReplyDump dump = afPacketDumpManager.getDump(id, ctx.getModificationCache())
- .or(new AfPacketDetailsReplyDump());
+ .orElse(new AfPacketDetailsReplyDump());
// Relying here that parent InterfaceCustomizer was invoked first to fill in the context with initial ifc mapping
final AfPacketDetails afPacketDetails = dump.afPacketDetails.stream()
.filter(detail -> detail.swIfIndex == index)
LOG.debug("Interface details for interface: {}, details: {}", ifaceName, iface);
final BridgeDomainDetailsReplyDump dumpReply = bdDumpManager.getDump(id, ctx.getModificationCache())
- .or(new BridgeDomainDetailsReplyDump());
+ .orElse(new BridgeDomainDetailsReplyDump());
for (final BridgeDomainDetails bd : dumpReply.bridgeDomainDetails) {
final Optional<BridgeDomainSwIf> bdIfAssignment = getBridgeDomainSwIf(ifaceId, bd);
if (bdIfAssignment.isPresent()) {
LOG.debug("Reading attributes for tapV2 interface: {}", key.getName());
final SwInterfaceTapV2DetailsReplyDump reply = tapV2DumpManager.getDump(id, ctx.getModificationCache())
- .or(new SwInterfaceTapV2DetailsReplyDump());
+ .orElse(new SwInterfaceTapV2DetailsReplyDump());
final Optional<SwInterfaceTapV2Details> detail = reply.swInterfaceTapV2Details.stream()
.filter(d -> d.swIfIndex == index)
final SwInterfaceVhostUserDetailsReplyDump dump =
vhostDumpManager.getDump(id, ctx.getModificationCache())
- .or(new SwInterfaceVhostUserDetailsReplyDump());
+ .orElse(new SwInterfaceVhostUserDetailsReplyDump());
// Relying here that parent InterfaceCustomizer was invoked first to fill in the context with initial ifc mapping
final SwInterfaceVhostUserDetails swInterfaceVhostUserDetails = dump.swInterfaceVhostUserDetails.stream()
identifier);
final SwInterfaceDetailsReplyDump reply =
specificDumpManager.getDump(identifier, ctx.getModificationCache(), interfaceName)
- .or(new SwInterfaceDetailsReplyDump());
+ .orElse(new SwInterfaceDetailsReplyDump());
if (reply.swInterfaceDetails.isEmpty()) {
return null;
LOG.debug("Performing dump[{}]", identifier);
final SwInterfaceDetailsReplyDump dump =
fullDumpManager.getDump(identifier, cache)
- .or(new SwInterfaceDetailsReplyDump());
+ .orElse(new SwInterfaceDetailsReplyDump());
// naming context initialization must be done here, as it is uses getName in next step, therefore it would
// create artificial mapping for every interface, because this happens before interface dump is processed
LOG.debug("deleteCurrentAttributes: id={}, dataBefore={}, ctx={}", id, dataBefore, ctx);
final String bdName = id.firstKeyOf(BridgeDomain.class).getName();
- final com.google.common.base.Optional<Interfaces> after =
+ final java.util.Optional<Interfaces> after =
ctx.readAfter(InstanceIdentifier.create(Interfaces.class));
if (after.isPresent()) {
package io.fd.hc2vpp.v3po.notification;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Lists;
import com.google.inject.Inject;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import java.util.Arrays;
import java.util.List;
doReturn(Optional.of(toIndex(1)))
.when(mappingContext)
.read(SPECIFIC_ID_1);
- doReturn(Optional.absent())
+ doReturn(Optional.empty())
.when(mappingContext)
.read(SPECIFIC_ID_4);
}
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class V3poModuleTest {
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.honeycomb.translate.util.RWUtils;
@Test
public void testWrite() throws WriteFailedException {
- when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final int vrfId = 123;
when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply()));
customizer.writeCurrentAttributes(IID, routing(vrfId), writeContext);
@Test(expected = WriteFailedException.class)
public void testWriteFailed() throws WriteFailedException {
- when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
when(api.swInterfaceSetTable(any())).thenReturn(failedFuture());
customizer.writeCurrentAttributes(IID, routing(213), writeContext);
}
@Test(expected = WriteFailedException.class)
public void testUpdateFailed() throws WriteFailedException {
- when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
when(api.swInterfaceSetTable(any())).thenReturn(failedFuture());
customizer.updateCurrentAttributes(IID, routing(123L), routing(321L), writeContext);
}
@Test
public void testDelete() throws WriteFailedException {
- when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply()));
customizer.deleteCurrentAttributes(IID, routing(123), writeContext);
verify(api).swInterfaceSetTable(expectedRequest(0));
@Test(expected = WriteFailedException.DeleteFailedException.class)
public void testDeleteFailed() throws WriteFailedException {
- when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
when(api.swInterfaceSetTable(any())).thenReturn(failedFuture());
customizer.deleteCurrentAttributes(IID, routing(123), writeContext);
}
import static org.mockito.Mockito.doReturn;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.write.WriteContext;
import org.mockito.Matchers;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
@Test
public void testWriteIpv4Vrf() throws WriteFailedException {
- when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final Routing v4Routing = new RoutingBuilder().setIpv4VrfId(new VniReference(4L)).build();
customizer.writeCurrentAttributes(VALID_ID, v4Routing, writeContext);
verifySetTableRequest(1, Collections.singleton(request(false, SUBIF_INDEX, 4)));
@Test
public void testWriteIpv6Vrf() throws WriteFailedException {
- when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final Routing v6Routing = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)).build();
customizer.writeCurrentAttributes(VALID_ID, v6Routing, writeContext);
verifySetTableRequest(1, Collections.singleton(request(true, SUBIF_INDEX, 3)));
@Test
public void testUpdateIpv4Vrf() throws WriteFailedException {
- when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final Routing routingBefore = new RoutingBuilder().setIpv6VrfId(new VniReference(3L))
.setIpv4VrfId(new VniReference(4L)).build();
final Routing routingAfter = new RoutingBuilder().setIpv6VrfId(new VniReference(3L))
@Test
public void testUpdateIpv6Vrf() throws WriteFailedException {
- when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final Routing routingBefore = new RoutingBuilder().setIpv6VrfId(new VniReference(3L))
.setIpv4VrfId(new VniReference(4L)).build();
final Routing routingAfter = new RoutingBuilder().setIpv6VrfId(new VniReference(8L))
@Test
public void testDeleteIpv4Vrf() throws WriteFailedException {
- when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final Routing v4Routing = new RoutingBuilder().setIpv4VrfId(new VniReference(4L)).build();
customizer.deleteCurrentAttributes(VALID_ID, v4Routing, writeContext);
verifySetTableRequest(1, Collections.singleton(request(false, SUBIF_INDEX, DISABLE_VRF)));
@Test
public void testDeleteIpv6Vrf() throws WriteFailedException {
- when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty());
final Routing v6Routing = new RoutingBuilder().setIpv6VrfId(new VniReference(3L)).build();
customizer.deleteCurrentAttributes(VALID_ID, v6Routing, writeContext);
verifySetTableRequest(1, Collections.singleton(request(true, SUBIF_INDEX, DISABLE_VRF)));
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.NamingContext;
final String bdName = "bd1";
final BridgeDomain bd = generateBridgeDomain(bdName);
defineMapping(mappingContext, bdName, bdId, BD_CTX_NAME);
- when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty());
whenBridgeDomainAddDelThenSuccess();
final String bdName = "bd1";
final BridgeDomain bd = generateBridgeDomain("bd1");
noMappingDefined(mappingContext, bdName, BD_CTX_NAME);
- when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty());
try {
customizer.deleteCurrentAttributes(bdIdentifierForName(bdName), bd, writeContext);
final String bdName = "bd1";
final BridgeDomain bd = generateBridgeDomain(bdName);
defineMapping(mappingContext, bdName, bdId, BD_CTX_NAME);
- when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent());
+ when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.empty());
whenBridgeDomainAddDelThenFailure();
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Iterables;
import com.google.common.collect.Multimap;
import io.fd.hc2vpp.common.test.util.FutureProducer;
private Optional<Integer> readTableIndex(@Nonnull final InstanceIdentifier<Policer> id, final int ifcIndex,
final byte type,
final ModificationCache cache) throws ReadFailedException {
- final
com.google.common.base.Optional<PolicerClassifyDetailsReplyDump> dump =
+ final
java.util.Optional<PolicerClassifyDetailsReplyDump> dump =
dumpManager.getDump(id, cache, type);
if (!dump.isPresent() || dump.get().policerClassifyDetails.isEmpty()) {
return Optional.empty();
package io.fd.hc2vpp.policer.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.primitives.Longs;
import com.google.common.primitives.UnsignedInts;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
package io.fd.hc2vpp.vpp.classifier.context;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import static com.google.common.base.Preconditions.checkState;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import com.google.inject.Inject;
import io.fd.honeycomb.translate.MappingContext;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Named;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.classifier.context.rev170502.VppClassifierContext;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.classifier.context.rev170502.VppClassifierContextBuilder;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.classifier.context.rev170502.vpp.classifier.context.ClassifyTableContext;
public Optional<String> getTableBaseNode(@Nonnull final String name, @Nonnull final MappingContext ctx) {
final Optional<ClassifyTableContext> read = ctx.read(getMappingIid(name));
if (read.isPresent()) {
- return Optional.fromNullable(read.get().getClassifierNodeName());
+ return Optional.ofNullable(read.get().getClassifierNodeName());
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
@Override
public Optional<String> getNodeName(final int tableIndex, final int nodeIndex, @Nonnull final MappingContext ctx) {
if (!containsName(tableIndex, ctx)) {
- return Optional.absent();
+ return Optional.empty();
}
final String tableName = getTableName(tableIndex, ctx);
final Optional<ClassifyTableContext> tableCtx = ctx.read(getMappingIid(tableName));
final List<NodeContext> nodeContext = tableCtx.get().getNodeContext();
if (nodeContext == null) {
- return Optional.absent();
+ return Optional.empty();
}
- return Optional.fromNullable(nodeContext.stream()
+ return Optional.ofNullable(nodeContext.stream()
.filter(n -> n.getIndex().equals(nodeIndex))
.findFirst()
.map(nodes -> nodes.getName())
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedInts;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
final List<ClassifySessionDetails> filteredSessions = details.stream()
.filter(singleDetail -> Arrays.equals(singleDetail.match, match)).collect(Collectors.toList());
if (filteredSessions.isEmpty()) {
- return Optional.absent();
+ return Optional.empty();
} else if (filteredSessions.size() == 1) {
return Optional.of(filteredSessions.get(0));
} else {
filteredSessions.size()));
}
}
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedInts;
import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
package io.fd.hc2vpp.vpp.classifier.read;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.vpp.classifier.context.VppClassifierContextManager;
import io.fd.honeycomb.translate.MappingContext;
import javax.annotation.Nonnull;
final PacketHandlingAction action = PacketHandlingAction.forValue(nodeIndex);
if (action == null) {
return vppClassifierContextManager.getNodeName(tableIndex, nodeIndex, ctx)
- .transform(nodeName -> new VppNode(new VppNodeName(nodeName)));
+ .map(nodeName -> new VppNode(new VppNodeName(nodeName)));
}
return Optional.of(new VppNode(action));
}
package io.fd.hc2vpp.vpp.classifier.write;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class VppClassifierModuleTest {
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import java.util.Arrays;
import org.junit.Before;
@Test
public void testContainsTable() throws Exception {
- when(ctx.read(TABLE_IID_0)).thenReturn(Optional.absent());
+ when(ctx.read(TABLE_IID_0)).thenReturn(Optional.empty());
assertFalse(vppClassfierContext.containsTable(TABLE_NAME_0, ctx));
}
final ClassifyTableContext tableCtx = table(TABLE_ID_0, TABLE_NAME_0, "aa");
when(ctx.read(VPP_CLASSIFIER_CONTEXT_IID)).thenReturn(Optional.of(context(tableCtx)));
when(ctx.read(TABLE_IID_0)).thenReturn(Optional.of(tableCtx));
- assertEquals(Optional.absent(), vppClassfierContext.getNodeName(TABLE_ID_0, 123, ctx));
+ assertEquals(Optional.empty(), vppClassfierContext.getNodeName(TABLE_ID_0, 123, ctx));
}
@Test
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
import io.fd.hc2vpp.vpp.classifier.context.VppClassifierContextManager;
import io.fd.honeycomb.translate.read.ReadFailedException;
when(classifierContext.containsTable(TABLE_NAME_1, mappingContext)).thenReturn(true);
when(classifierContext.getTableIndex(TABLE_NAME_1, mappingContext)).thenReturn(TABLE_INDEX_1);
- when(classifierContext.getTableBaseNode(TABLE_NAME_1, mappingContext)).thenReturn(Optional.absent());
+ when(classifierContext.getTableBaseNode(TABLE_NAME_1, mappingContext)).thenReturn(Optional.empty());
final ClassifyTableBuilder builder = mock(ClassifyTableBuilder.class);
getCustomizer().readCurrentAttributes(getClassifyTableId(TABLE_NAME_1), builder, ctx);
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.vpp.classifier.context.VppClassifierContextManager;
@Test(expected = IllegalStateException.class)
public void testDeleteMisssingTable() throws WriteFailedException {
- when(writeContext.readAfter(ArgumentMatchers.any())).thenReturn(Optional.absent());
+ when(writeContext.readAfter(ArgumentMatchers.any())).thenReturn(Optional.empty());
final String match = "00:00:00:00:00:00:01:02:03:04:05:06:00:00:00:00";
final ClassifySession classifySession = generateClassifySession(SESSION_INDEX, match);
final InstanceIdentifier<ClassifySession> id = getClassifySessionId(TABLE_NAME, match);
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
import io.fd.honeycomb.translate.util.read.BindingBrokerReader;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.naming.context.rev160513.Contexts;
import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.naming.context.rev160513.ContextsBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.hc2vpp.common.context.ContextsReaderFactory;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
/**
* Mirror of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.context.impl.rev141210.ContextReaderModule
import java.util.Set;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public class VppCommonModuleTest {
import static org.mockito.Mockito.doReturn;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.MappingContext;
import java.util.List;
final List<Mapping> list = Common.getMappingList(mappingContext, iid);
doReturn(Optional.of(new MappingsBuilder().setMapping(list).build())).when(mappingContext).read(iid);
- doReturn(Optional.absent()).when(mappingContext).read(mappingIid(name, namingContextName));
+ doReturn(Optional.empty()).when(mappingContext).read(mappingIid(name, namingContextName));
}
final class Common {
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.util.RWUtils;
import java.util.Collections;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.util.RWUtils;
import java.util.List;
@Nonnull final MappingContext mappingContext) {
final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class));
if (!read.isPresent()) {
- return Optional.absent();
+ return Optional.empty();
}
final List<Mapping> mappings = read.get().getMapping().stream()
} else if (mappings.size() == 1) {
return Optional.of(mappings.get(0).getName());
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import io.fd.honeycomb.test.tools.HoneycombTestRunner;
import io.fd.honeycomb.test.tools.annotations.InjectTestData;
import io.fd.honeycomb.test.tools.annotations.InjectablesProcessor;
.child(MultiNaming.class, new MultiNamingKey("context"));
when(mappingContext.read(multiNamingContextIid.child(Mappings.class))).thenReturn(Optional.of(mappings));
- when(mappingContext.read(parentKey(NON_EXISTING_PARENT))).thenReturn(Optional.absent());
+ when(mappingContext.read(parentKey(NON_EXISTING_PARENT))).thenReturn(Optional.empty());
when(mappingContext.read(parentKey(PARENT_1))).thenReturn(Optional.of(filterForParent(PARENT_1)));
when(mappingContext.read(parentKey(PARENT_2))).thenReturn(Optional.of(filterForParent(PARENT_2)));
when(mappingContext.read(parentKey(PARENT_3))).thenReturn(Optional.of(filterForParent(PARENT_3)));
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Lists;
import io.fd.honeycomb.test.tools.HoneycombTestRunner;
import io.fd.honeycomb.test.tools.annotations.InjectTestData;
@Test
public void addNameNoMapings() throws Exception {
- when(mappingContext.read(namingContextIid.child(Mappings.class))).thenReturn(Optional.absent());
+ when(mappingContext.read(namingContextIid.child(Mappings.class))).thenReturn(Optional.empty());
namingContext.addName("name-0", mappingContext);
verify(mappingContext, times(1))
@Test(expected = IllegalArgumentException.class)
public void getAndThrow() {
- when(mappingContext.read(any())).thenReturn(Optional.absent());
+ when(mappingContext.read(any())).thenReturn(Optional.empty());
namingContext
.getIndex("non-existing", mappingContext, () -> new IllegalArgumentException("Non existing index"));
}
final Mappings mappings = new MappingsBuilder().setMapping(Lists.newArrayList(mapping1)).build();
when(mappingContext.read(namingContextIid.child(Mappings.class))).thenReturn(Optional.of(mappings));
- assertEquals(Optional.absent(), namingContext.getNameIfPresent(0, mappingContext));
+ assertEquals(Optional.empty(), namingContext.getNameIfPresent(0, mappingContext));
}
@Test
import io.fd.jvpp.core.future.FutureJVppCore;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
/**
* Use to bypass jvpp registration, and infra modules
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.collect.Iterables;
import com.google.common.collect.Multimap;
import io.fd.hc2vpp.common.test.util.FutureProducer;
Code Review / hc2vpp.git / commitdiff