Lisp test coverage increased to ~80%

Change-Id: Id4e9072ebb8d66e532e30c1dc3bb6036bfdc9012
Signed-off-by: Jan Srnicek <jsrnicek@cisco.com>

22 files changed, 1606 insertions, 0 deletions

diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/initializers/LispInitializerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/initializers/LispInitializerTest.java
new file mode 100644
index 000000000..087f2cdee
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/initializers/LispInitializerTest.java
@@ -0,0 +1,42 @@
+package io.fd.honeycomb.lisp.translate.initializers;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.LispState;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.LispStateBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTableBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.LocatorSetsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.MapResolversBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.pitr.cfg.grouping.PitrCfgBuilder;
+
+
+public class LispInitializerTest {
+    @Test
+    public void convert() throws Exception {
+
+        final LispInitializer initializer = new LispInitializer(mock(DataBroker.class));
+        final LispState state = new LispStateBuilder()
+                .setEnable(true)
+                .setEidTable(new EidTableBuilder().build())
+                .setLocatorSets(new LocatorSetsBuilder().build())
+                .setMapResolvers(new MapResolversBuilder().build())
+                .setPitrCfg(new PitrCfgBuilder().build())
+                .build();
+
+        final Lisp operational = initializer.convert(state);
+
+        assertNotNull(operational);
+        assertEquals(operational.getPitrCfg(), state.getPitrCfg());
+        assertEquals(operational.isEnable(), state.isEnable());
+        assertEquals(operational.getEidTable(), state.getEidTable());
+        assertEquals(operational.getLocatorSets(), state.getLocatorSets());
+        assertEquals(operational.getMapResolvers(), state.getMapResolvers());
+
+    }
+
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/AdjacencyCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/AdjacencyCustomizerTest.java
new file mode 100644
index 000000000..0a88f946c
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/AdjacencyCustomizerTest.java
@@ -0,0 +1,44 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertTrue;
+
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.AdjacenciesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.AdjacencyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.AdjacencyKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+
+public class AdjacencyCustomizerTest extends ListReaderCustomizerTest<Adjacency, AdjacencyKey, AdjacencyBuilder> {
+
+    private InstanceIdentifier<Adjacency> identifier;
+
+    public AdjacencyCustomizerTest() {
+        super(Adjacency.class, AdjacenciesBuilder.class);
+    }
+
+    @Before
+    public void init() {
+        identifier = InstanceIdentifier.create(Adjacency.class);
+    }
+
+    @Test
+    public void getAllIds() throws Exception {
+        assertTrue(getCustomizer().getAllIds(identifier, ctx).isEmpty());
+    }
+
+    @Test(expected = ReadFailedException.class)
+    public void readCurrentAttributes() throws Exception {
+        getCustomizer().readCurrentAttributes(identifier, new AdjacencyBuilder(), ctx);
+    }
+
+    @Override
+    protected ReaderCustomizer<Adjacency, AdjacencyBuilder> initCustomizer() {
+        return new AdjacencyCustomizer(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/InterfaceCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/InterfaceCustomizerTest.java
new file mode 100644
index 000000000..3c87a7540
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/InterfaceCustomizerTest.java
@@ -0,0 +1,102 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.LocatorSets;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSetKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.locator.set.Interface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.locator.set.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.locator.set.InterfaceKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispLocatorDetails;
+import org.openvpp.jvpp.core.dto.LispLocatorDetailsReplyDump;
+
+public class InterfaceCustomizerTest
+        extends ListReaderCustomizerTest<Interface, InterfaceKey, InterfaceBuilder> {
+
+    public InterfaceCustomizerTest() {
+        super(Interface.class, LocatorSetBuilder.class);
+    }
+
+    private InstanceIdentifier<Interface> validId;
+
+    @Before
+    public void init() {
+        validId = InstanceIdentifier.create(LocatorSets.class).child(LocatorSet.class, new LocatorSetKey("loc-set-1"))
+                .child(Interface.class, new InterfaceKey("interface-1"));
+
+        //mappings
+        defineMappings();
+        //dump data
+        defineDumpData();
+    }
+
+    private void defineDumpData() {
+        final LispLocatorDetailsReplyDump dump = new LispLocatorDetailsReplyDump();
+
+        final LispLocatorDetails detail1 = new LispLocatorDetails();
+        detail1.swIfIndex = 1;
+        detail1.ipAddress = new byte[]{-64, -88, 2, 1};
+        detail1.isIpv6 = 0;
+        detail1.local = 0;
+        detail1.priority = 1;
+        detail1.weight = 2;
+
+        final LispLocatorDetails detail2 = new LispLocatorDetails();
+        detail2.swIfIndex = 2;
+        detail2.ipAddress = new byte[]{-64, -88, 2, 2};
+        detail2.isIpv6 = 0;
+        detail2.local = 0;
+        detail2.priority = 2;
+        detail2.weight = 3;
+
+        dump.lispLocatorDetails = ImmutableList.of(detail1, detail2);
+
+        when(api.lispLocatorDump(Mockito.any())).thenReturn(future(dump));
+    }
+
+    private void defineMappings() {
+        defineMapping(mappingContext, "interface-1", 1, "interface-context");
+        defineMapping(mappingContext, "interface-2", 2, "interface-context");
+        defineMapping(mappingContext, "loc-set-1", 3, "locator-set-context");
+    }
+
+    @Test
+    public void testGetAllIds() throws ReadFailedException {
+
+        final List<InterfaceKey> keys = getCustomizer().getAllIds(validId, ctx);
+
+        assertEquals(2, keys.size());
+        assertEquals("interface-1", keys.get(0).getInterfaceRef());
+        assertEquals("interface-2", keys.get(1).getInterfaceRef());
+    }
+
+    @Test
+    public void testReadCurrentAttributes() throws ReadFailedException {
+        InterfaceBuilder builder = new InterfaceBuilder();
+        getCustomizer().readCurrentAttributes(validId, builder, ctx);
+
+        final Interface iface = builder.build();
+        assertEquals("interface-1", iface.getInterfaceRef());
+        assertEquals("interface-1", iface.getKey().getInterfaceRef());
+
+    }
+
+    @Override
+    protected ReaderCustomizer<Interface, InterfaceBuilder> initCustomizer() {
+        return new InterfaceCustomizer(api, new NamingContext("interface", "interface-context"),
+                new NamingContext("loc-set", "locator-set-context"));
+    }
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LispStateCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LispStateCustomizerTest.java
new file mode 100644
index 000000000..4a76debc7
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LispStateCustomizerTest.java
@@ -0,0 +1,52 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.LispState;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.LispStateBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.ShowLispStatusReply;
+
+public class LispStateCustomizerTest extends ReaderCustomizerTest<LispState, LispStateBuilder> {
+
+    private InstanceIdentifier<LispState> identifier;
+
+    public LispStateCustomizerTest() {
+        super(LispState.class, null);
+    }
+
+    @Before
+    public void init() {
+        identifier = InstanceIdentifier.create(LispState.class);
+        final ShowLispStatusReply reply = new ShowLispStatusReply();
+        reply.featureStatus = 1;
+
+        when(api.showLispStatus(Mockito.any())).thenReturn(future(reply));
+    }
+
+    @Test
+    public void testReadCurrentAttributes() throws ReadFailedException {
+
+        LispStateBuilder builder = new LispStateBuilder();
+        getCustomizer().readCurrentAttributes(identifier, builder, ctx);
+
+        assertEquals(true, builder.build().isEnable());
+    }
+
+    @Override
+    protected ReaderCustomizer<LispState, LispStateBuilder> initCustomizer() {
+        return new LispStateCustomizer(api);
+    }
+
+    @Override
+    public void testMerge() throws Exception {
+        //LispState is root node, so there is no way to implement merge(it is also not needed)
+    }
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocalMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocalMappingCustomizerTest.java
new file mode 100644
index 000000000..b874bce48
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocalMappingCustomizerTest.java
@@ -0,0 +1,120 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.lisp.context.util.EidMappingContext;
+import io.fd.honeycomb.lisp.translate.util.EidTranslator;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
+import java.util.List;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.EidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.MappingId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.LocalMappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.LocalMappingsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.LocalMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.LocalMappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.LocalMappingKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.local.mapping.Eid;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispEidTableDetails;
+import org.openvpp.jvpp.core.dto.LispEidTableDetailsReplyDump;
+
+public class LocalMappingCustomizerTest extends
+        ListReaderCustomizerTest<LocalMapping, LocalMappingKey, LocalMappingBuilder> implements EidTranslator {
+
+    private static final Ipv4
+            EID_ADDRESS = new Ipv4Builder().setIpv4(new Ipv4Address("192.168.2.1")).build();
+
+    @Mock
+    private EidMappingContext localMappingContext;
+
+    private InstanceIdentifier<LocalMapping> emptyIdentifier;
+    private InstanceIdentifier<LocalMapping> validIdentifier;
+
+    public LocalMappingCustomizerTest() {
+        super(LocalMapping.class, LocalMappingsBuilder.class);
+    }
+
+
+    public void setUp() {
+        emptyIdentifier = InstanceIdentifier.create(EidTable.class)
+                .child(VniTable.class, new VniTableKey(12L))
+                .child(LocalMappings.class)
+                .child(LocalMapping.class);
+
+        validIdentifier = InstanceIdentifier.create(EidTable.class)
+                .child(VniTable.class, new VniTableKey(12L))
+                .child(LocalMappings.class)
+                .child(LocalMapping.class, new LocalMappingKey(new MappingId("local-mapping")));
+
+        defineDumpData();
+        defineMappings();
+    }
+
+    private void defineDumpData() {
+        LispEidTableDetailsReplyDump replyDump = new LispEidTableDetailsReplyDump();
+        LispEidTableDetails detail = new LispEidTableDetails();
+        detail.action = 0;
+        detail.authoritative = 1;
+        detail.context = 4;
+        detail.eid = new byte[]{-64, -88, 2, 1};
+        detail.eidPrefixLen = 32;
+        detail.isLocal = 1;
+        detail.locatorSetIndex = 1;
+        detail.ttl = 7;
+        detail.vni = 12;
+
+        replyDump.lispEidTableDetails = ImmutableList.of(detail);
+        when(api.lispEidTableDump(any())).thenReturn(future(replyDump));
+    }
+
+    private void defineMappings() {
+        //eid mapping
+
+        when(localMappingContext.getId(any(Eid.class), any(MappingContext.class))).thenReturn(new MappingId("local-mapping"));
+        when(localMappingContext.containsEid(new MappingId("local-mapping"), mappingContext)).thenReturn(true);
+        when(localMappingContext.getEid(new MappingId("local-mapping"), mappingContext)).thenReturn(new EidBuilder()
+                .setAddress(EID_ADDRESS).build());
+        //naming context for locator
+        defineMapping(mappingContext, "loc-set", 1, "locator-set-context");
+    }
+
+    @Test
+    public void readCurrentAttributes() throws Exception {
+        LocalMappingBuilder builder = new LocalMappingBuilder();
+        getCustomizer().readCurrentAttributes(validIdentifier, builder, ctx);
+
+        final LocalMapping mapping = builder.build();
+
+        assertNotNull(mapping);
+        assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress()));
+        assertEquals("loc-set", mapping.getLocatorSet());
+    }
+
+    @Test
+    public void getAllIds() throws Exception {
+        final List<LocalMappingKey> keys = getCustomizer().getAllIds(emptyIdentifier, ctx);
+
+        assertEquals(1, keys.size());
+        assertEquals("local-mapping", keys.get(0).getId().getValue());
+    }
+
+    @Override
+    protected ReaderCustomizer<LocalMapping, LocalMappingBuilder> initCustomizer() {
+        return new LocalMappingCustomizer(api, new NamingContext("loc", "locator-set-context"), localMappingContext);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocatorSetCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocatorSetCustomizerTest.java
new file mode 100644
index 000000000..2c40c2fdf
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocatorSetCustomizerTest.java
@@ -0,0 +1,80 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.LocatorSets;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.LocatorSetsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSetKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDetails;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDetailsReplyDump;
+
+
+public class LocatorSetCustomizerTest
+        extends ListReaderCustomizerTest<LocatorSet, LocatorSetKey, LocatorSetBuilder> {
+
+    private InstanceIdentifier<LocatorSet> emptyId;
+    private InstanceIdentifier<LocatorSet> validId;
+
+    public LocatorSetCustomizerTest() {
+        super(LocatorSet.class, LocatorSetsBuilder.class);
+    }
+
+    @Before
+    public void init() {
+        emptyId = InstanceIdentifier.create(LocatorSet.class);
+        validId = InstanceIdentifier.create(LocatorSets.class).child(LocatorSet.class, new LocatorSetKey("loc-set"));
+
+        defineDumpData();
+        defineMapping(mappingContext, "loc-set", 1, "locator-set-context");
+    }
+
+    private void defineDumpData() {
+        LispLocatorSetDetailsReplyDump dump = new LispLocatorSetDetailsReplyDump();
+        LispLocatorSetDetails detail = new LispLocatorSetDetails();
+        detail.context = 4;
+        detail.lsName = "loc-set".getBytes(StandardCharsets.UTF_8);
+        detail.lsIndex = 1;
+
+        dump.lispLocatorSetDetails = ImmutableList.of(detail);
+
+        when(api.lispLocatorSetDump(any())).thenReturn(future(dump));
+    }
+
+
+    @Test
+    public void readCurrentAttributes() throws Exception {
+        LocatorSetBuilder builder = new LocatorSetBuilder();
+        getCustomizer().readCurrentAttributes(validId, builder, ctx);
+
+        assertNotNull(builder);
+        assertEquals("loc-set", builder.getName());
+        assertEquals("loc-set", builder.getKey().getName());
+    }
+
+    @Test
+    public void getAllIds() throws Exception {
+        final List<LocatorSetKey> keys = getCustomizer().getAllIds(emptyId, ctx);
+
+        assertEquals(1, keys.size());
+        assertEquals("loc-set", keys.get(0).getName());
+    }
+
+    @Override
+    protected ReaderCustomizer<LocatorSet, LocatorSetBuilder> initCustomizer() {
+        return new LocatorSetCustomizer(api, new NamingContext("loc", "locator-set-context"));
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/MapResolverCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/MapResolverCustomizerTest.java
new file mode 100644
index 000000000..be5d1c7f0
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/MapResolverCustomizerTest.java
@@ -0,0 +1,87 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.MapResolvers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.MapResolversBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.map.resolvers.MapResolver;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.map.resolvers.MapResolverBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.map.resolvers.MapResolverKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispMapResolverDetails;
+import org.openvpp.jvpp.core.dto.LispMapResolverDetailsReplyDump;
+
+
+public class MapResolverCustomizerTest
+        extends ListReaderCustomizerTest<MapResolver, MapResolverKey, MapResolverBuilder> {
+
+    private static final IpAddress IP_ADDRESS = new IpAddress(new Ipv4AddressNoZone("192.168.2.1"));
+    private static final IpAddress IP_ADDRESS_REVERTED =
+            new IpAddress(new Ipv4AddressNoZone("1.2.168.192"));
+
+    private InstanceIdentifier<MapResolver> emptyId;
+    private InstanceIdentifier<MapResolver> validId;
+
+    public MapResolverCustomizerTest() {
+        super(MapResolver.class, MapResolversBuilder.class);
+    }
+
+    @Before
+    public void init() {
+
+        emptyId = InstanceIdentifier.create(MapResolver.class);
+        validId = InstanceIdentifier.create(MapResolvers.class)
+                .child(MapResolver.class, new MapResolverKey(IP_ADDRESS_REVERTED));
+        defineDumpData();
+    }
+
+    @Test
+    public void readCurrentAttributes() throws Exception {
+        MapResolverBuilder builder = new MapResolverBuilder();
+        getCustomizer().readCurrentAttributes(validId, builder, ctx);
+
+        MapResolver resolver = builder.build();
+        assertNotNull(resolver);
+        assertEquals("1.2.168.192", resolver.getIpAddress().getIpv4Address().getValue());
+    }
+
+    @Test
+    public void getAllIds() throws Exception {
+        final List<MapResolverKey> keys = getCustomizer().getAllIds(emptyId, ctx);
+
+        assertEquals(1, keys.size());
+
+        final MapResolverKey key = keys.get(0);
+        assertNotNull(key);
+        assertEquals("192.168.2.1", new String(key.getIpAddress().getValue()));
+
+    }
+
+    private void defineDumpData() {
+        final LispMapResolverDetailsReplyDump replyDump = new LispMapResolverDetailsReplyDump();
+        final LispMapResolverDetails detail = new LispMapResolverDetails();
+        detail.context = 5;
+        detail.ipAddress = new byte[]{1, 2, -88, -64};
+        detail.isIpv6 = 0;
+
+        replyDump.lispMapResolverDetails = ImmutableList.of(detail);
+
+        when(api.lispMapResolverDump(any())).thenReturn(future(replyDump));
+    }
+
+    @Override
+    protected ReaderCustomizer<MapResolver, MapResolverBuilder> initCustomizer() {
+        return new MapResolverCustomizer(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/PitrCfgCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/PitrCfgCustomizerTest.java
new file mode 100644
index 000000000..a752b736e
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/PitrCfgCustomizerTest.java
@@ -0,0 +1,62 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest;
+import java.nio.charset.StandardCharsets;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.LispStateBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.pitr.cfg.grouping.PitrCfg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.pitr.cfg.grouping.PitrCfgBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.ShowLispPitrReply;
+
+
+public class PitrCfgCustomizerTest extends ReaderCustomizerTest<PitrCfg, PitrCfgBuilder> {
+
+    private static final byte[] LOC_SET_NAME_BYTES = "loc-set".getBytes(StandardCharsets.UTF_8);
+
+    private InstanceIdentifier<PitrCfg> emptyId;
+    private PitrCfg validData;
+
+    public PitrCfgCustomizerTest() {
+        super(PitrCfg.class, LispStateBuilder.class);
+    }
+
+    @Before
+    public void init() {
+        emptyId = InstanceIdentifier.create(PitrCfg.class);
+        validData = new PitrCfgBuilder().setLocatorSet("loc-set").build();
+
+        mockDumpData();
+    }
+
+    @Test
+    public void readCurrentAttributes() throws Exception {
+        PitrCfgBuilder builder = new PitrCfgBuilder();
+        getCustomizer().readCurrentAttributes(emptyId, builder, ctx);
+
+        final PitrCfg cfg = builder.build();
+
+        assertNotNull(cfg);
+        assertEquals("loc-set", cfg.getLocatorSet());
+    }
+
+    private void mockDumpData() {
+        ShowLispPitrReply replyDump = new ShowLispPitrReply();
+        replyDump.locatorSetName = LOC_SET_NAME_BYTES;
+        replyDump.status = 1;
+
+        when(api.showLispPitr(any())).thenReturn(future(replyDump));
+    }
+
+    @Override
+    protected ReaderCustomizer<PitrCfg, PitrCfgBuilder> initCustomizer() {
+        return new PitrCfgCustomizer(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/RemoteMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/RemoteMappingCustomizerTest.java
new file mode 100644
index 000000000..ea3a1e002
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/RemoteMappingCustomizerTest.java
@@ -0,0 +1,125 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.lisp.context.util.EidMappingContext;
+import io.fd.honeycomb.lisp.translate.util.EidTranslator;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.EidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.MappingId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.RemoteMappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.RemoteMappingsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.RemoteMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.RemoteMappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.RemoteMappingKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.Eid;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispEidTableDetails;
+import org.openvpp.jvpp.core.dto.LispEidTableDetailsReplyDump;
+
+public class RemoteMappingCustomizerTest
+        extends ListReaderCustomizerTest<RemoteMapping, RemoteMappingKey, RemoteMappingBuilder>
+        implements EidTranslator {
+
+    private static final Ipv4
+            EID_ADDRESS = new Ipv4Builder().setIpv4(new Ipv4Address("192.168.2.1")).build();
+
+    @Mock
+    private EidMappingContext eidMappingContext;
+
+    private InstanceIdentifier<RemoteMapping> emptyId;
+    private InstanceIdentifier<RemoteMapping> validId;
+
+    public RemoteMappingCustomizerTest() {
+        super(RemoteMapping.class, RemoteMappingsBuilder.class);
+    }
+
+    @Before
+    public void init() {
+
+        emptyId = InstanceIdentifier.create(EidTable.class)
+                .child(VniTable.class, new VniTableKey(12L))
+                .child(RemoteMappings.class)
+                .child(RemoteMapping.class);
+
+        validId = InstanceIdentifier.create(EidTable.class)
+                .child(VniTable.class, new VniTableKey(12L))
+                .child(RemoteMappings.class)
+                .child(RemoteMapping.class, new RemoteMappingKey(new MappingId("remote-mapping")));
+
+        mockDumpData();
+        mockMappings();
+    }
+
+
+    private void mockDumpData() {
+        LispEidTableDetailsReplyDump replyDump = new LispEidTableDetailsReplyDump();
+        LispEidTableDetails detail = new LispEidTableDetails();
+        detail.action = 0;
+        detail.authoritative = 1;
+        detail.context = 4;
+        detail.eid = new byte[]{-64, -88, 2, 1};
+        detail.eidPrefixLen = 32;
+        detail.isLocal = 0;
+        detail.locatorSetIndex = 1;
+        detail.ttl = 7;
+        detail.vni = 12;
+
+        replyDump.lispEidTableDetails = ImmutableList.of(detail);
+
+        when(api.lispEidTableDump(any())).thenReturn(future(replyDump));
+    }
+
+    private void mockMappings() {
+
+        when(eidMappingContext.getId(any(Eid.class), any(MappingContext.class)))
+                .thenReturn(new MappingId("remote-mapping"));
+        when(eidMappingContext.containsEid(new MappingId("remote-mapping"), mappingContext)).thenReturn(true);
+        when(eidMappingContext.getEid(new MappingId("remote-mapping"), mappingContext))
+                .thenReturn(new EidBuilder().setAddress(EID_ADDRESS).build());
+    }
+
+    @Test
+    public void readCurrentAttributes() throws Exception {
+        RemoteMappingBuilder builder = new RemoteMappingBuilder();
+        getCustomizer().readCurrentAttributes(validId, builder, ctx);
+
+        RemoteMapping mapping = builder.build();
+
+        assertNotNull(mapping);
+        assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress()));
+        assertEquals(true, mapping.getAuthoritative().isA());
+        assertEquals(7L, mapping.getTtl().longValue());
+    }
+
+
+    @Test
+    public void getAllIds() throws Exception {
+        final List<RemoteMappingKey> keys = getCustomizer().getAllIds(validId, ctx);
+
+        assertNotNull(keys);
+        assertEquals(1, keys.size());
+        assertEquals("remote-mapping", keys.get(0).getId().getValue());
+    }
+
+    @Override
+    protected ReaderCustomizer<RemoteMapping, RemoteMappingBuilder> initCustomizer() {
+        return new RemoteMappingCustomizer(api, eidMappingContext);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VniTableCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VniTableCustomizerTest.java
new file mode 100644
index 000000000..c83887a6e
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VniTableCustomizerTest.java
@@ -0,0 +1,75 @@
+package io.fd.honeycomb.lisp.translate.read;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTableBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispEidTableMapDetails;
+import org.openvpp.jvpp.core.dto.LispEidTableMapDetailsReplyDump;
+
+
+public class VniTableCustomizerTest extends ListReaderCustomizerTest<VniTable, VniTableKey, VniTableBuilder> {
+
+    private InstanceIdentifier<VniTable> validId;
+
+    public VniTableCustomizerTest() {
+        super(VniTable.class, EidTableBuilder.class);
+    }
+
+    @Before
+    public void init() {
+        validId = InstanceIdentifier.create(EidTable.class).child(VniTable.class, new VniTableKey(2L));
+
+        final LispEidTableMapDetailsReplyDump replyDump = new LispEidTableMapDetailsReplyDump();
+        final LispEidTableMapDetails detail = new LispEidTableMapDetails();
+        detail.dpTable = 3;
+        detail.vni = 2;
+        detail.context = 4;
+        replyDump.lispEidTableMapDetails = ImmutableList.of(detail);
+
+        when(api.lispEidTableMapDump(any())).thenReturn(future(replyDump));
+    }
+
+    @Test
+    public void getAllIds() throws Exception {
+        final List<VniTableKey> keys = getCustomizer().getAllIds(validId, ctx);
+
+        assertEquals(1, keys.size());
+
+        final VniTableKey key = keys.get(0);
+        assertNotNull(key);
+        //due to ambigous call (long,long) vs (Object,Object)
+        assertEquals(2L, key.getVirtualNetworkIdentifier().longValue());
+
+    }
+
+    @Test
+    public void readCurrentAttributes() throws Exception {
+        VniTableBuilder builder = new VniTableBuilder();
+        getCustomizer().readCurrentAttributes(validId, builder, ctx);
+
+        final VniTable table = builder.build();
+
+        assertNotNull(table);
+        assertEquals(3L, table.getTableId().longValue());
+        assertEquals(2L, table.getVirtualNetworkIdentifier().longValue());
+    }
+
+    @Override
+    protected ReaderCustomizer<VniTable, VniTableBuilder> initCustomizer() {
+        return new VniTableCustomizer(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/LocatorDumpCheckTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/LocatorDumpCheckTest.java
new file mode 100644
index 000000000..8c52eb930
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/LocatorDumpCheckTest.java
@@ -0,0 +1,25 @@
+package io.fd.honeycomb.lisp.translate.read.dump.check;
+
+import io.fd.honeycomb.vpp.test.read.DumpCheckTest;
+import org.openvpp.jvpp.core.dto.LispLocatorDetailsReplyDump;
+
+public class LocatorDumpCheckTest extends DumpCheckTest<LocatorDumpCheck, LispLocatorDetailsReplyDump> {
+
+    @Override
+    protected LocatorDumpCheck initCheck() {
+        return new LocatorDumpCheck();
+    }
+
+    @Override
+    protected LispLocatorDetailsReplyDump initEmptyData() {
+        final LispLocatorDetailsReplyDump replyDump = new LispLocatorDetailsReplyDump();
+        replyDump.lispLocatorDetails = null;
+
+        return replyDump;
+    }
+
+    @Override
+    protected LispLocatorDetailsReplyDump initValidData() {
+        return new LispLocatorDetailsReplyDump();
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/LocatorSetsDumpCheckTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/LocatorSetsDumpCheckTest.java
new file mode 100644
index 000000000..f932c22e5
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/LocatorSetsDumpCheckTest.java
@@ -0,0 +1,26 @@
+package io.fd.honeycomb.lisp.translate.read.dump.check;
+
+import io.fd.honeycomb.vpp.test.read.DumpCheckTest;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDetailsReplyDump;
+
+
+public class LocatorSetsDumpCheckTest extends DumpCheckTest<LocatorSetsDumpCheck, LispLocatorSetDetailsReplyDump> {
+
+    @Override
+    protected LocatorSetsDumpCheck initCheck() {
+        return new LocatorSetsDumpCheck();
+    }
+
+    @Override
+    protected LispLocatorSetDetailsReplyDump initEmptyData() {
+        final LispLocatorSetDetailsReplyDump replyDump = new LispLocatorSetDetailsReplyDump();
+        replyDump.lispLocatorSetDetails = null;
+
+        return replyDump;
+    }
+
+    @Override
+    protected LispLocatorSetDetailsReplyDump initValidData() {
+        return new LispLocatorSetDetailsReplyDump();
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/MapResolverDumpCheckTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/MapResolverDumpCheckTest.java
new file mode 100644
index 000000000..236f3c494
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/MapResolverDumpCheckTest.java
@@ -0,0 +1,26 @@
+package io.fd.honeycomb.lisp.translate.read.dump.check;
+
+import io.fd.honeycomb.vpp.test.read.DumpCheckTest;
+import org.openvpp.jvpp.core.dto.LispMapResolverDetailsReplyDump;
+
+
+public class MapResolverDumpCheckTest extends DumpCheckTest<MapResolverDumpCheck, LispMapResolverDetailsReplyDump> {
+
+    @Override
+    protected MapResolverDumpCheck initCheck() {
+        return new MapResolverDumpCheck();
+    }
+
+    @Override
+    protected LispMapResolverDetailsReplyDump initEmptyData() {
+        final LispMapResolverDetailsReplyDump replyDump = new LispMapResolverDetailsReplyDump();
+        replyDump.lispMapResolverDetails = null;
+
+        return replyDump;
+    }
+
+    @Override
+    protected LispMapResolverDetailsReplyDump initValidData() {
+        return new LispMapResolverDetailsReplyDump();
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/MappingsDumpCheckTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/MappingsDumpCheckTest.java
new file mode 100644
index 000000000..6378e5f6b
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/MappingsDumpCheckTest.java
@@ -0,0 +1,26 @@
+package io.fd.honeycomb.lisp.translate.read.dump.check;
+
+import io.fd.honeycomb.vpp.test.read.DumpCheckTest;
+import org.openvpp.jvpp.core.dto.LispEidTableDetailsReplyDump;
+
+
+public class MappingsDumpCheckTest extends DumpCheckTest<MappingsDumpCheck, LispEidTableDetailsReplyDump> {
+
+    @Override
+    protected MappingsDumpCheck initCheck() {
+        return new MappingsDumpCheck();
+    }
+
+    @Override
+    protected LispEidTableDetailsReplyDump initEmptyData() {
+        final LispEidTableDetailsReplyDump replyDump = new LispEidTableDetailsReplyDump();
+        replyDump.lispEidTableDetails = null;
+
+        return replyDump;
+    }
+
+    @Override
+    protected LispEidTableDetailsReplyDump initValidData() {
+        return new LispEidTableDetailsReplyDump();
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/VniTableDumpCheckTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/VniTableDumpCheckTest.java
new file mode 100644
index 000000000..5f70e8a1e
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/check/VniTableDumpCheckTest.java
@@ -0,0 +1,26 @@
+package io.fd.honeycomb.lisp.translate.read.dump.check;
+
+import io.fd.honeycomb.vpp.test.read.DumpCheckTest;
+import org.openvpp.jvpp.core.dto.LispEidTableMapDetailsReplyDump;
+
+
+public class VniTableDumpCheckTest extends DumpCheckTest<VniTableDumpCheck, LispEidTableMapDetailsReplyDump> {
+
+    @Override
+    protected VniTableDumpCheck initCheck() {
+        return new VniTableDumpCheck();
+    }
+
+    @Override
+    protected LispEidTableMapDetailsReplyDump initEmptyData() {
+        final LispEidTableMapDetailsReplyDump replyDump = new LispEidTableMapDetailsReplyDump();
+        replyDump.lispEidTableMapDetails = null;
+
+        return replyDump;
+    }
+
+    @Override
+    protected LispEidTableMapDetailsReplyDump initValidData() {
+        return new LispEidTableMapDetailsReplyDump();
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/LocatorDumpExecutorTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/LocatorDumpExecutorTest.java
new file mode 100644
index 000000000..efa655bf1
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/LocatorDumpExecutorTest.java
@@ -0,0 +1,105 @@
+package io.fd.honeycomb.lisp.translate.read.dump.executor;
+
+
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.LocatorDumpParams.LocatorDumpParamsBuilder;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.lisp.translate.read.dump.executor.params.LocatorDumpParams;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpTimeoutException;
+import io.fd.honeycomb.vpp.test.read.JvppDumpExecutorTest;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mockito;
+import org.openvpp.jvpp.core.dto.LispLocatorDetails;
+import org.openvpp.jvpp.core.dto.LispLocatorDetailsReplyDump;
+import org.openvpp.jvpp.core.dto.LispLocatorDump;
+
+
+public class LocatorDumpExecutorTest extends JvppDumpExecutorTest<LocatorDumpExecutor> {
+
+    @Captor
+    private ArgumentCaptor<LispLocatorDump> requestCaptor;
+
+    private LispLocatorDetailsReplyDump validDump;
+
+    @Before
+    public void init() {
+        validDump = new LispLocatorDetailsReplyDump();
+        LispLocatorDetails detail = new LispLocatorDetails();
+
+        detail.swIfIndex = 1;
+        detail.priority = 2;
+        detail.local = 1;
+        detail.weight = 3;
+        detail.isIpv6 = 0;
+        detail.context = 8;
+        detail.ipAddress = new byte[]{-64, -88, 4, 2};
+
+        validDump.lispLocatorDetails = ImmutableList.of(detail);
+    }
+
+    @Test
+    public void testExecuteDumpTimeout() throws Exception {
+        doThrowTimeoutExceptionWhen().lispLocatorDump(Mockito.any());
+        try {
+            getExecutor().executeDump(new LocatorDumpParamsBuilder().build());
+        } catch (Exception e) {
+            assertTrue(e instanceof DumpTimeoutException);
+            assertTrue(e.getCause() instanceof TimeoutException);
+            return;
+        }
+        fail("Test should have thrown exception");
+    }
+
+    @Test(expected = DumpCallFailedException.class)
+    public void testExecuteDumpHalted() throws DumpExecutionFailedException {
+        doThrowFailExceptionWhen().lispLocatorDump(Mockito.any());
+        getExecutor().executeDump(new LocatorDumpParamsBuilder().build());
+    }
+
+    @Test
+    public void testExecuteDump() throws DumpExecutionFailedException {
+        doReturnResponseWhen(validDump).lispLocatorDump(Mockito.any());
+
+        final LocatorDumpParams params = new LocatorDumpParamsBuilder().setLocatorSetIndex(5).build();
+
+        final LispLocatorDetailsReplyDump reply = getExecutor().executeDump(params);
+        verify(api, times(1)).lispLocatorDump(requestCaptor.capture());
+
+        final LispLocatorDump request = requestCaptor.getValue();
+
+        //check passed params
+        assertNotNull(request);
+        assertEquals(5, request.lsIndex);
+
+        //check result
+        assertNotNull(reply);
+        assertEquals(1, reply.lispLocatorDetails.size());
+
+        final LispLocatorDetails details = reply.lispLocatorDetails.get(0);
+        assertEquals(1, details.swIfIndex);
+        assertEquals(2, details.priority);
+        assertEquals(1, details.local);
+        assertEquals(3, details.weight);
+        assertEquals(0, details.isIpv6);
+        assertEquals(8, details.context);
+        assertArrayEquals(new byte[]{-64, -88, 4, 2}, details.ipAddress);
+    }
+
+    @Override
+    protected LocatorDumpExecutor initExecutor() {
+        return new LocatorDumpExecutor(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/LocatorSetsDumpExecutorTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/LocatorSetsDumpExecutorTest.java
new file mode 100644
index 000000000..5daf77a3d
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/LocatorSetsDumpExecutorTest.java
@@ -0,0 +1,95 @@
+package io.fd.honeycomb.lisp.translate.read.dump.executor;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpTimeoutException;
+import io.fd.honeycomb.vpp.test.read.JvppDumpExecutorTest;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDetails;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDetailsReplyDump;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDump;
+
+
+public class LocatorSetsDumpExecutorTest extends JvppDumpExecutorTest<LocatorSetsDumpExecutor> {
+
+    public static final byte[] LOCATOR_SET_NAME_BYTES = "loc-set".getBytes(StandardCharsets.UTF_8);
+
+    private LispLocatorSetDetailsReplyDump validDump;
+
+    @Captor
+    private ArgumentCaptor<LispLocatorSetDump> requestCaptor;
+
+    @Before
+    public void init() {
+        validDump = new LispLocatorSetDetailsReplyDump();
+        LispLocatorSetDetails detail = new LispLocatorSetDetails();
+        detail.lsIndex = 2;
+        detail.lsName = LOCATOR_SET_NAME_BYTES;
+        detail.context = 4;
+
+        validDump.lispLocatorSetDetails = ImmutableList.of(detail);
+    }
+
+    @Test
+    public void testExecuteDumpTimeout() throws Exception {
+        doThrowTimeoutExceptionWhen().lispLocatorSetDump(any());
+        try {
+            getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+        } catch (Exception e) {
+            assertTrue(e instanceof DumpTimeoutException);
+            assertTrue(e.getCause() instanceof TimeoutException);
+            return;
+        }
+        fail("Test should have thrown exception");
+    }
+
+    @Test(expected = DumpCallFailedException.class)
+    public void testExecuteDumpHalted() throws DumpExecutionFailedException {
+        doThrowFailExceptionWhen().lispLocatorSetDump(any());
+        getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+    }
+
+    @Test
+    public void testExecuteDump() throws DumpExecutionFailedException {
+        doReturnResponseWhen(validDump).lispLocatorSetDump(any());
+
+        final LispLocatorSetDetailsReplyDump replyDump = getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+        verify(api, times(1)).lispLocatorSetDump(requestCaptor.capture());
+
+        final LispLocatorSetDump request = requestCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(1, request.filter);
+
+        assertNotNull(replyDump);
+        assertNotNull(replyDump.lispLocatorSetDetails);
+        assertEquals(1, replyDump.lispLocatorSetDetails.size());
+        final LispLocatorSetDetails detail = replyDump.lispLocatorSetDetails.get(0);
+
+        assertNotNull(detail);
+        assertEquals(4, detail.context);
+        assertEquals(2, detail.lsIndex);
+        assertEquals(LOCATOR_SET_NAME_BYTES, detail.lsName);
+    }
+
+    @Override
+    protected LocatorSetsDumpExecutor initExecutor() {
+        return new LocatorSetsDumpExecutor(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/MapResolversDumpExecutorTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/MapResolversDumpExecutorTest.java
new file mode 100644
index 000000000..446300365
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/MapResolversDumpExecutorTest.java
@@ -0,0 +1,76 @@
+package io.fd.honeycomb.lisp.translate.read.dump.executor;
+
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpTimeoutException;
+import io.fd.honeycomb.vpp.test.read.JvppDumpExecutorTest;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.openvpp.jvpp.core.dto.LispMapResolverDetails;
+import org.openvpp.jvpp.core.dto.LispMapResolverDetailsReplyDump;
+
+
+public class MapResolversDumpExecutorTest extends JvppDumpExecutorTest<MapResolversDumpExecutor> {
+
+    private LispMapResolverDetailsReplyDump validDump;
+
+    @Before
+    public void init() {
+        validDump = new LispMapResolverDetailsReplyDump();
+        final LispMapResolverDetails details = new LispMapResolverDetails();
+        details.isIpv6 = 0;
+        details.ipAddress = new byte[]{-64, -88, 5, 4};
+        details.context = 7;
+
+        validDump.lispMapResolverDetails = ImmutableList.of(details);
+    }
+
+    @Test
+    public void testExecuteDumpTimeout() throws Exception {
+        doThrowTimeoutExceptionWhen().lispMapResolverDump(Mockito.any());
+        try {
+            getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+        } catch (Exception e) {
+            assertTrue(e instanceof DumpTimeoutException);
+            assertTrue(e.getCause() instanceof TimeoutException);
+            return;
+        }
+        fail("Test should have thrown exception");
+    }
+
+    @Test(expected = DumpCallFailedException.class)
+    public void testExecuteDumpHalted() throws DumpExecutionFailedException {
+        doThrowFailExceptionWhen().lispMapResolverDump(Mockito.any());
+        getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+    }
+
+    @Test
+    public void testExecuteDump() throws DumpExecutionFailedException {
+        doReturnResponseWhen(validDump).lispMapResolverDump(Mockito.any());
+        final LispMapResolverDetailsReplyDump reply = getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+
+        assertNotNull(reply);
+        assertEquals(1, reply.lispMapResolverDetails.size());
+
+        final LispMapResolverDetails detail = reply.lispMapResolverDetails.get(0);
+        assertEquals(7, detail.context);
+        assertEquals(0, detail.isIpv6);
+        assertArrayEquals(new byte[]{-64, -88, 5, 4}, detail.ipAddress);
+    }
+
+    @Override
+    protected MapResolversDumpExecutor initExecutor() {
+        return new MapResolversDumpExecutor(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/MappingsDumpExecutorTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/MappingsDumpExecutorTest.java
new file mode 100644
index 000000000..85b22fa7e
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/MappingsDumpExecutorTest.java
@@ -0,0 +1,121 @@
+package io.fd.honeycomb.lisp.translate.read.dump.executor;
+
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType;
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.FilterType;
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.MappingsDumpParamsBuilder;
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.QuantityType;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpTimeoutException;
+import io.fd.honeycomb.vpp.test.read.JvppDumpExecutorTest;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.openvpp.jvpp.core.dto.LispEidTableDetails;
+import org.openvpp.jvpp.core.dto.LispEidTableDetailsReplyDump;
+import org.openvpp.jvpp.core.dto.LispEidTableDump;
+
+public class MappingsDumpExecutorTest extends JvppDumpExecutorTest<MappingsDumpExecutor> {
+
+    private static final byte[] EID = {-64, -88, 2, 1};
+
+    @Captor
+    private ArgumentCaptor<LispEidTableDump> requestCaptor;
+
+    private LispEidTableDetailsReplyDump validDump;
+    private MappingsDumpParams emptyParams;
+    private MappingsDumpParams validParams;
+
+    @Before
+    public void init() {
+        validDump = new LispEidTableDetailsReplyDump();
+
+        LispEidTableDetails detail = new LispEidTableDetails();
+        detail.action = 0;
+        detail.authoritative = 1;
+        detail.context = 4;
+        detail.eid = new byte[]{-64, -88, 2, 1};
+        detail.eidPrefixLen = 32;
+        detail.isLocal = 1;
+        detail.locatorSetIndex = 2;
+        detail.ttl = 7;
+        detail.vni = 2;
+
+        validDump.lispEidTableDetails = ImmutableList.of(detail);
+
+        emptyParams = MappingsDumpParamsBuilder.newInstance().build();
+        validParams =
+                MappingsDumpParamsBuilder.newInstance().setVni(2).setPrefixLength((byte) 32).setEidSet(QuantityType.ALL)
+                        .setEid(EID)
+                        .setEidType(EidType.IPV4).setFilter(FilterType.LOCAL).build();
+    }
+
+    @Test
+    public void testExecuteDumpTimeout() throws Exception {
+        doThrowTimeoutExceptionWhen().lispEidTableDump(any());
+        try {
+            getExecutor().executeDump(emptyParams);
+        } catch (Exception e) {
+            assertTrue(e instanceof DumpTimeoutException);
+            assertTrue(e.getCause() instanceof TimeoutException);
+            return;
+        }
+        fail("Test should have thrown exception");
+    }
+
+    @Test(expected = DumpCallFailedException.class)
+    public void testExecuteDumpHalted() throws DumpExecutionFailedException {
+        doThrowFailExceptionWhen().lispEidTableDump(any());
+        getExecutor().executeDump(emptyParams);
+    }
+
+    @Test
+    public void testExecuteDump() throws DumpExecutionFailedException {
+        doReturnResponseWhen(validDump).lispEidTableDump(any());
+        final LispEidTableDetailsReplyDump reply = getExecutor().executeDump(validParams);
+        verify(api, times(1)).lispEidTableDump(requestCaptor.capture());
+
+        final LispEidTableDump request = requestCaptor.getValue();
+        assertNotNull(request);
+        assertEquals(2, request.vni);
+        assertEquals(QuantityType.ALL.getValue(), request.eidSet);
+        assertArrayEquals(EID, request.eid);
+        assertEquals(EidType.IPV4.getValue(), request.eidType);
+        assertEquals(FilterType.LOCAL.getValue(), request.filter);
+        assertEquals(32, request.prefixLength);
+
+        assertNotNull(reply);
+        assertEquals(1, reply.lispEidTableDetails.size());
+
+        final LispEidTableDetails detail = reply.lispEidTableDetails.get(0);
+
+        assertNotNull(detail);
+        assertEquals(0, detail.action);
+        assertEquals(1, detail.authoritative);
+        assertEquals(4, detail.context);
+        assertArrayEquals(EID, detail.eid);
+        assertEquals(32, detail.eidPrefixLen);
+        assertEquals(1, detail.isLocal);
+        assertEquals(2, detail.locatorSetIndex);
+        assertEquals(7, detail.ttl);
+        assertEquals(2, detail.vni);
+    }
+
+    @Override
+    protected MappingsDumpExecutor initExecutor() {
+        return new MappingsDumpExecutor(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/VniTableDumpExecutorTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/VniTableDumpExecutorTest.java
new file mode 100644
index 000000000..13033bf65
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/VniTableDumpExecutorTest.java
@@ -0,0 +1,76 @@
+package io.fd.honeycomb.lisp.translate.read.dump.executor;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecutionFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException;
+import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpTimeoutException;
+import io.fd.honeycomb.vpp.test.read.JvppDumpExecutorTest;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.openvpp.jvpp.core.dto.LispEidTableMapDetails;
+import org.openvpp.jvpp.core.dto.LispEidTableMapDetailsReplyDump;
+
+
+public class VniTableDumpExecutorTest extends JvppDumpExecutorTest<VniTableDumpExecutor> {
+
+    private LispEidTableMapDetailsReplyDump validDump;
+
+    @Before
+    public void init() {
+        validDump = new LispEidTableMapDetailsReplyDump();
+        LispEidTableMapDetails detail = new LispEidTableMapDetails();
+        detail.dpTable = 1;
+        detail.vni = 2;
+        detail.context = 4;
+        validDump.lispEidTableMapDetails = ImmutableList.of(detail);
+    }
+
+    @Test(expected = DumpCallFailedException.class)
+    public void testExecuteDumpFail() throws DumpExecutionFailedException {
+        doThrowFailExceptionWhen().lispEidTableMapDump(Mockito.any());
+        getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+    }
+
+
+    @Test
+    public void testExecuteDumpTimeout() throws Exception {
+        doThrowTimeoutExceptionWhen().lispEidTableMapDump(Mockito.any());
+        try {
+            getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+        } catch (Exception e) {
+            assertTrue(e instanceof DumpTimeoutException);
+            assertTrue(e.getCause() instanceof TimeoutException);
+            return;
+        }
+        fail("Test should have thrown exception");
+    }
+
+    @Test
+    public void testExecuteDump() throws DumpExecutionFailedException {
+
+        doReturnResponseWhen(validDump).lispEidTableMapDump(Mockito.any());
+        final LispEidTableMapDetailsReplyDump reply = getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS);
+
+        assertNotNull(reply);
+        assertEquals(1, reply.lispEidTableMapDetails.size());
+        final LispEidTableMapDetails detail = reply.lispEidTableMapDetails.get(0);
+
+        assertEquals(4, detail.context);
+        assertEquals(1, detail.dpTable);
+        assertEquals(2, detail.vni);
+    }
+
+    @Override
+    protected VniTableDumpExecutor initExecutor() {
+        return new VniTableDumpExecutor(api);
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/AdjacencyCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/AdjacencyCustomizerTest.java
new file mode 100644
index 000000000..d6c5816e1
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/AdjacencyCustomizerTest.java
@@ -0,0 +1,129 @@
+package io.fd.honeycomb.lisp.translate.write;
+
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType.IPV4;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.Adjacencies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.AdjacencyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.adjacency.LocalEidBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.adjacency.RemoteEidBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispAddDelAdjacency;
+import org.openvpp.jvpp.core.dto.LispAddDelAdjacencyReply;
+
+public class AdjacencyCustomizerTest extends WriterCustomizerTest {
+
+    @Captor
+    private ArgumentCaptor<LispAddDelAdjacency> requestCaptor;
+
+    private AdjacencyCustomizer customizer;
+
+    private InstanceIdentifier<Adjacency> emptyId;
+    private InstanceIdentifier<Adjacency> validId;
+
+    private Adjacency emptyData;
+    private Adjacency invalidData;
+    private Adjacency validData;
+
+    @Before
+    public void init() {
+        customizer = new AdjacencyCustomizer(api);
+
+        emptyId = InstanceIdentifier.create(Adjacency.class);
+        validId = InstanceIdentifier.create(EidTable.class)
+                .child(VniTable.class, new VniTableKey(2L))
+                .child(Adjacencies.class)
+                .child(Adjacency.class);
+
+        emptyData = new AdjacencyBuilder().build();
+
+        invalidData = new AdjacencyBuilder().setId("ID").setLocalEid(
+                new LocalEidBuilder().setAddress(new Ipv4Builder().setIpv4(new Ipv4Address("192.168.2.1")).build())
+                        .build()).setRemoteEid(
+                new RemoteEidBuilder().setAddress(new MacBuilder().setMac(new MacAddress("aa:aa:aa:aa:aa:aa")).build())
+                        .build())
+                .build();
+
+        validData = new AdjacencyBuilder().setId("ID").setLocalEid(
+                new LocalEidBuilder().setAddress(new Ipv4Builder().setIpv4(new Ipv4Address("192.168.2.1")).build())
+                        .build()).setRemoteEid(
+                new RemoteEidBuilder()
+                        .setAddress(new Ipv4Builder().setIpv4(new Ipv4Address("192.168.5.2")).build()).build()).build();
+
+        when(api.lispAddDelAdjacency(any())).thenReturn(future(new LispAddDelAdjacencyReply()));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void writeCurrentAttributesNoKey() throws Exception {
+        customizer.writeCurrentAttributes(emptyId, emptyData, writeContext);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void writeCurrentAttributesInvalidCombination() throws Exception {
+        customizer.writeCurrentAttributes(emptyId, invalidData, writeContext);
+    }
+
+    @Test
+    public void writeCurrentAttributes() throws Exception {
+        customizer.writeCurrentAttributes(validId, validData, writeContext);
+        verify(api, times(1)).lispAddDelAdjacency(requestCaptor.capture());
+        verifyRequest(requestCaptor.getValue(), 1, new byte[]{-64, -88, 2, 1}, 32, new byte[]{-64, -88, 5, 2},
+                32, IPV4.getValue(), 2);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void updateCurrentAttributes() throws Exception {
+        customizer.updateCurrentAttributes(emptyId, emptyData, emptyData, writeContext);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void deleteCurrentAttributesNoKey() throws Exception {
+        customizer.deleteCurrentAttributes(emptyId, emptyData, writeContext);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void deleteCurrentAttributesInvalidCombination() throws Exception {
+        customizer.deleteCurrentAttributes(validId, invalidData, writeContext);
+    }
+
+    @Test
+    public void deleteCurrentAttributes() throws Exception {
+        customizer.deleteCurrentAttributes(validId, validData, writeContext);
+        verify(api, times(1)).lispAddDelAdjacency(requestCaptor.capture());
+        verifyRequest(requestCaptor.getValue(), 0, new byte[]{-64, -88, 2, 1}, 32, new byte[]{-64, -88, 5, 2},
+                32, IPV4.getValue(), 2);
+    }
+
+    private static void verifyRequest(final LispAddDelAdjacency request, final int isAdd, final byte[] seid,
+                                      final int seidLen, final byte[] deid, final int deidLen, final int eidType,
+                                      final int vni) {
+
+        assertNotNull(request);
+        assertEquals(isAdd, request.isAdd);
+        assertArrayEquals(seid, request.seid);
+        assertEquals(seidLen, request.seidLen);
+        assertArrayEquals(deid, request.deid);
+        assertEquals(eidType, request.eidType);
+        assertEquals(vni, request.vni);
+
+    }
+}
\ No newline at end of file
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/VniTableCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/VniTableCustomizerTest.java
new file mode 100644
index 000000000..a6bd5b967
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/VniTableCustomizerTest.java
@@ -0,0 +1,86 @@
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispEidTableAddDelMap;
+import org.openvpp.jvpp.core.dto.LispEidTableAddDelMapReply;
+
+
+public class VniTableCustomizerTest extends WriterCustomizerTest {
+
+    @Captor
+    private ArgumentCaptor<LispEidTableAddDelMap> requestCaptor;
+
+    private VniTableCustomizer customizer;
+    private InstanceIdentifier<VniTable> emptyId;
+
+    private VniTable emptyData;
+    private VniTable validData;
+
+    @Before
+    public void init() {
+        customizer = new VniTableCustomizer(api);
+
+        emptyId = InstanceIdentifier.create(VniTable.class);
+
+        emptyData = new VniTableBuilder().build();
+        validData = new VniTableBuilder().setTableId(2L).setVirtualNetworkIdentifier(3L).build();
+
+        when(api.lispEidTableAddDelMap(any())).thenReturn(future(new LispEidTableAddDelMapReply()));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesEmptyData() throws Exception {
+        customizer.writeCurrentAttributes(emptyId, emptyData, writeContext);
+    }
+
+
+    @Test
+    public void testWriteCurrentAttributes() throws Exception {
+        customizer.writeCurrentAttributes(emptyId, validData, writeContext);
+        verify(api, times(1)).lispEidTableAddDelMap(requestCaptor.capture());
+        verifyRequest(requestCaptor.getValue(), (byte) 1, 2L, 3L);
+    }
+
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdateCurrentAttributes() throws Exception {
+        customizer.updateCurrentAttributes(emptyId, emptyData, emptyData, writeContext);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesEmptyData() throws Exception {
+        customizer.deleteCurrentAttributes(emptyId, emptyData, writeContext);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws Exception {
+        customizer.deleteCurrentAttributes(emptyId, validData, writeContext);
+        verify(api, times(1)).lispEidTableAddDelMap(requestCaptor.capture());
+        verifyRequest(requestCaptor.getValue(), (byte) 0, 2L, 3L);
+    }
+
+    private static void verifyRequest(final LispEidTableAddDelMap request, final byte isAdd,
+                                      final long dpTable,
+                                      final long vni) {
+        assertNotNull(request);
+        assertEquals(isAdd, request.isAdd);
+        assertEquals(dpTable, request.dpTable);
+        assertEquals(vni, request.vni);
+
+    }
+
+}
\ No newline at end of file