Code Review / lispflowmapping.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Update DAO API
[lispflowmapping.git] / mappingservice / implementation / src / test / java / org / opendaylight / lispflowmapping / implementation / lisp / MapServerTest.java
diff --git a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java
index 24c0f63762dcc9d65a2341c98ca47121749dfcd0..8c37737138ce91d06b550216c4aadcd8f2a754c8 100644 (file)
--- a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java
+++ b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java
@@ -18,13 +18,11 @@ import junitx.framework.ArrayAssert;
 import org.junit.Before;
 import org.junit.Test;
 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
-import org.opendaylight.lispflowmapping.implementation.dao.MappingKeyUtil;
-import org.opendaylight.lispflowmapping.implementation.util.DAOSubKeys;
 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
-import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
+import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
 import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
+import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord.Action;
@@ -33,6 +31,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.Ma
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecordBuilder;
@@ -43,10 +42,12 @@ public class MapServerTest extends BaseTestCase {
     private LispMappingService testedMapServer;
     private ILispDAO lispDAO;
     private MapRegisterBuilder mapRegisterBuilder;
-    private LispAFIAddress eid;
-    private LispAFIAddress rloc;
+    private LispAddressContainer eid;
+    private LispAddressContainer rloc;
     private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
     private MapRegister mapRegisterWithAuthentication;
+    private String eidIpv4String = "10.31.0.5";
+    private String eidIpv6String = "1:1:1:1:1:1:1:0";
 
     @Override
     @Before
@@ -58,12 +59,12 @@ public class MapServerTest extends BaseTestCase {
         mapRegisterBuilder = new MapRegisterBuilder();
         mapRegisterBuilder.setKeyId((short) 0);
         mapRegisterBuilder.setAuthenticationData(new byte[0]);
-        eid = LispAFIConvertor.asIPAfiAddress("10.31.0.5");
-        rloc = LispAFIConvertor.asIPAfiAddress("192.168.136.10");
+        eid = LispAFIConvertor.asIPv4Address(eidIpv4String);
+        rloc = LispAFIConvertor.asIPv4Address("192.168.136.10");
         EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32);
+        recordBuilder.setLispAddressContainer(eid).setMaskLength((short) 32);
         recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
-        recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc)).build());
+        recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(rloc).build());
         recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60).setMaskLength((short) 32);
         mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
@@ -81,15 +82,14 @@ public class MapServerTest extends BaseTestCase {
     public void handleMapRegister__NonSetMBit() throws Exception {
         mapRegisterBuilder.setWantMapNotify(false);
 
-        addDefaultPutAndGetExpectations(eid, 32);
+        addDefaultPutAndGetExpectations(eid);
         assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false));
 
         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
         assertEquals(1, entries.length);
-
-        assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
-        assertEquals(1, ((RLOCGroup) entries[0].getValue()).getRecords().size());
-        assertEquals(rloc, LispAFIConvertor.toAFI(((RLOCGroup) entries[0].getValue()).getRecords().get(0).getLispAddressContainer()));
+        assertEquals(SubKeys.RECORD, entries[0].getKey());
+        assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue())
+                .getLocatorRecord().get(0).getLispAddressContainer());
     }
 
     @Test
@@ -98,8 +98,8 @@ public class MapServerTest extends BaseTestCase {
                 getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoAddressBuilder().build())).build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(eid, 32);
-        addDefaultPutAndGetExpectations(new NoAddressBuilder().build(), 32);
+        addDefaultPutAndGetExpectations(eid);
+        addDefaultPutAndGetExpectations(LispAFIConvertor.toContainer(new NoAddressBuilder().build()));
         MapRegister mr = mapRegisterBuilder.build();
         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
@@ -114,8 +114,8 @@ public class MapServerTest extends BaseTestCase {
         mapRegisterBuilder.setWantMapNotify(true);
         EidToLocatorRecordBuilder eidToLocatorBuilder = getDefaultEidToLocatorBuilder();
         eidToLocatorBuilder.setMaskLength((short) 32);
-        eid = LispAFIConvertor.asIPAfiAddress("0.0.0.1");
-        eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+        eid = LispAFIConvertor.asIPv4Address("0.0.0.1");
+        eidToLocatorBuilder.setLispAddressContainer(eid);
 
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.2")));
@@ -124,12 +124,12 @@ public class MapServerTest extends BaseTestCase {
 
         mapRegisterBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build());
 
-        addDefaultPutAndGetExpectations(eid, 32);
+        addDefaultPutAndGetExpectations(eid);
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 
         EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0);
-        assertEquals(LispAFIConvertor.toContainer(eid), actualEidToLocator.getLispAddressContainer());
+        assertEquals(eid, actualEidToLocator.getLispAddressContainer());
         assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue());
 
     }
@@ -137,21 +137,21 @@ public class MapServerTest extends BaseTestCase {
     @Test
     public void handleMapRegisterIpv4__ValidMask() throws Exception {
         int mask = 16;
+        LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
+        recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
-        locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+        locator.setLispAddressContainer(rloc);
         recordBuilder.getLocatorRecord().add(locator.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
         MapRegister mr = mapRegisterBuilder.build();
 
-        addDefaultPutAndGetExpectations(eid, mask);
+        addDefaultPutAndGetExpectations(newEid);
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
-        assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
-                .getLispAddressContainer());
+        assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
@@ -162,21 +162,21 @@ public class MapServerTest extends BaseTestCase {
     public void handleMapRegister__NonMaskable() throws Exception {
         int mask = 16;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01");
+        LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
+        locatorBuilder.setLispAddressContainer(rloc);
+        recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(addr, mask);
+        addDefaultPutAndGetExpectations(addr);
 
         MapRegister mapRegister = mapRegisterBuilder.build();
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
-        assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
@@ -187,21 +187,21 @@ public class MapServerTest extends BaseTestCase {
     public void handleMapRegister__ZeroMask() throws Exception {
         int mask = 0;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01");
+        LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
+        locatorBuilder.setLispAddressContainer(rloc);
+        recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(addr, mask);
+        addDefaultPutAndGetExpectations(addr);
 
         MapRegister mapRegister = mapRegisterBuilder.build();
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
-        assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
@@ -211,21 +211,21 @@ public class MapServerTest extends BaseTestCase {
     @Test
     public void handleMapRegisterIPv4__ZeroMask() throws Exception {
         int mask = 0;
+        LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
+        recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
-        locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+        locator.setLispAddressContainer(rloc);
         recordBuilder.getLocatorRecord().add(locator.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
         MapRegister mr = mapRegisterBuilder.build();
 
-        addDefaultPutAndGetExpectations(eid, mask);
+        addDefaultPutAndGetExpectations(newEid);
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
-        assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
-                .getLispAddressContainer());
+        assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
@@ -237,19 +237,18 @@ public class MapServerTest extends BaseTestCase {
         int mask = 32;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
+        recordBuilder.setLispAddressContainer(eid).setMaskLength((short) mask);
         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
-        locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+        locator.setLispAddressContainer(rloc);
         recordBuilder.getLocatorRecord().add(locator.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
         MapRegister mr = mapRegisterBuilder.build();
 
-        addDefaultPutAndGetExpectations(eid, mask);
+        addDefaultPutAndGetExpectations(eid);
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
-        assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
-                .getLispAddressContainer());
+        assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
@@ -260,21 +259,21 @@ public class MapServerTest extends BaseTestCase {
     public void handleMapRegisterIpv6__ValidMask96() throws Exception {
         int mask = 96;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
+        LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
+        locatorBuilder.setLispAddressContainer(rloc);
+        recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(addr, mask);
+        addDefaultPutAndGetExpectations(addr);
 
         MapRegister mapRegister = mapRegisterBuilder.build();
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
-        assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
@@ -285,21 +284,21 @@ public class MapServerTest extends BaseTestCase {
     public void handleMapRegisterIpv6__ZeroMask() throws Exception {
         int mask = 0;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
+        LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
+        locatorBuilder.setLispAddressContainer(rloc);
+        recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(addr, mask);
+        addDefaultPutAndGetExpectations(addr);
 
         MapRegister mapRegister = mapRegisterBuilder.build();
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
-        assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
@@ -310,21 +309,21 @@ public class MapServerTest extends BaseTestCase {
     public void handleMapRegisterIpv6__ValidMask48() throws Exception {
         int mask = 48;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
+        LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
+        locatorBuilder.setLispAddressContainer(rloc);
+        recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(addr, mask);
+        addDefaultPutAndGetExpectations(addr);
 
         MapRegister mapRegister = mapRegisterBuilder.build();
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
-        assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
@@ -335,21 +334,21 @@ public class MapServerTest extends BaseTestCase {
     public void handleMapRegisterIpv6__ValidMask128() throws Exception {
         int mask = 128;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
+        LispAddressContainer addr = LispAFIConvertor.asIPv6Address(eidIpv6String);
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
+        locatorBuilder.setLispAddressContainer(rloc);
+        recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(addr, mask);
+        addDefaultPutAndGetExpectations(addr);
 
         MapRegister mapRegister = mapRegisterBuilder.build();
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
-        assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
@@ -361,26 +360,26 @@ public class MapServerTest extends BaseTestCase {
         int mask = 96;
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
         EidToLocatorRecordBuilder recordBuilder0 = getDefaultEidToLocatorBuilder();
-        recordBuilder0.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32);
-        LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
+        recordBuilder0.setLispAddressContainer(eid).setMaskLength((short) 32);
+        LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
         EidToLocatorRecordBuilder recordBuilder1 = getDefaultEidToLocatorBuilder();
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
-        recordBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
+        locatorBuilder.setLispAddressContainer(rloc);
+        locatorBuilder.setLispAddressContainer(rloc);
+        recordBuilder1.setLispAddressContainer(addr).setMaskLength((short) mask);
         recordBuilder1.getLocatorRecord().add(locatorBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder0.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder1.build());
         mapRegisterBuilder.setWantMapNotify(true);
 
-        addDefaultPutAndGetExpectations(eid, 32);
-        addDefaultPutAndGetExpectations(addr, mask);
+        addDefaultPutAndGetExpectations(eid);
+        addDefaultPutAndGetExpectations(addr);
 
         MapRegister mapRegister = mapRegisterBuilder.build();
 
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
-        assertEquals(LispAFIConvertor.toContainer(eid), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
-        assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
+        assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(addr, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
@@ -389,17 +388,17 @@ public class MapServerTest extends BaseTestCase {
 
     @Test
     public void handleMapRegister__MultipleRLOCs() throws Exception {
-        addDefaultPutAndGetExpectations(eid, 32);
+        addDefaultPutAndGetExpectations(eid);
 
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress rloc0 = rloc;
-        LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
+        LispAddressContainer rloc0 = rloc;
+        LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+        recordBuilder.setLispAddressContainer(eid);
         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
-        locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0));
+        locatorBuilder1.setLispAddressContainer(rloc0);
         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
-        locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
+        locatorBuilder2.setLispAddressContainer(rloc1);
         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
         recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
 
@@ -410,29 +409,29 @@ public class MapServerTest extends BaseTestCase {
         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
         assertEquals(1, entries.length);
 
-        assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
-        assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
-                .getLispAddressContainer());
-        assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[0].getValue()).getRecords().get(1)
-                .getLispAddressContainer());
+        assertEquals(SubKeys.RECORD, entries[0].getKey());
+        assertEquals(rloc0, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
+                .get(0).getLispAddressContainer());
+        assertEquals(rloc1, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
+                .get(1).getLispAddressContainer());
 
     }
 
     @Test
     public void handleMapRegister__MultipleTypes() throws Exception {
-        addDefaultPutAndGetExpectations(eid, 32);
+        addDefaultPutAndGetExpectations(eid);
 
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
-        LispAFIAddress rloc0 = rloc;
+        LispAddressContainer rloc0 = rloc;
         // LispAFIAddress rloc1 =
         // LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
         String subkey = "bla";
         LispAFIAddress rloc1 = LispAFIConvertor
                 .asKeyValue(subkey, LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7")));
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+        recordBuilder.setLispAddressContainer(eid);
         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
-        locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0));
+        locatorBuilder1.setLispAddressContainer(rloc0);
         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
         locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
@@ -443,53 +442,52 @@ public class MapServerTest extends BaseTestCase {
         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 
         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
-        assertEquals(2, entries.length);
-
-        assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
-        assertEquals(subkey, entries[1].getKey());
-        assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
-                .getLispAddressContainer());
-        assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[1].getValue()).getRecords().get(0)
+        assertEquals(1, entries.length);
+        EidToLocatorRecord storedMapping = (EidToLocatorRecord) entries[0].getValue();
+        assertEquals(2, storedMapping.getLocatorRecord().size());
+        assertEquals(SubKeys.RECORD, entries[0].getKey());
+        assertEquals(rloc0, storedMapping.getLocatorRecord().get(0).getLispAddressContainer());
+        assertEquals(LispAFIConvertor.toContainer(rloc1), storedMapping.getLocatorRecord().get(1)
                 .getLispAddressContainer());
 
     }
 
     @Test
     public void handleMapRegister__TestOverwrite() throws Exception {
-        addDefaultPutAndGetExpectations(eid, 32);
+        addDefaultPutAndGetExpectations(eid);
 
         addEidToLocatorRecord();
 
         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
         assertEquals(1, entries.length);
 
-        assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
-        assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
-                .getLispAddressContainer());
-    }
-
-    @Test
-    public void handleMapRegister__TestDontOverwrite() throws Exception {
-        int hc = LispAFIConvertor.toContainer(rloc).getAddress().hashCode();
-
-        addDefaultPutAndGetExpectations(eid, 32);
-        testedMapServer.setOverwrite(false);
-
-        addEidToLocatorRecord();
-
-        MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
-        assertEquals(1, entries.length);
-
-        assertEquals(String.valueOf(hc), entries[0].getKey());
-        assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
-                .getLispAddressContainer());
-    }
+        assertEquals(SubKeys.RECORD, entries[0].getKey());
+        assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
+                .get(0).getLispAddressContainer());
+    }
+
+//    @Test
+//    public void handleMapRegister__TestDontOverwrite() throws Exception {
+//        int hc = rloc.getAddress().hashCode();
+//
+//        addDefaultPutAndGetExpectations(eid);
+//        testedMapServer.setOverwrite(false);
+//
+//        addEidToLocatorRecord();
+//
+//        MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
+//        assertEquals(1, entries.length);
+//
+//        assertEquals(String.valueOf(hc), entries[0].getKey());
+//        assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
+//                .get(0).getLispAddressContainer());
+//    }
 
     private void addEidToLocatorRecord() {
         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
-        recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+        recordBuilder.setLispAddressContainer(eid);
         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
-        locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
+        locatorBuilder.setLispAddressContainer(rloc);
         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
@@ -500,18 +498,18 @@ public class MapServerTest extends BaseTestCase {
 
     @Test
     public void handleMapRegister__MultipleEIDs() throws Exception {
-        addDefaultPutAndGetExpectations(eid, 32);
+        addDefaultPutAndGetExpectations(eid);
 
-        LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
+        LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
         mapRegisterBuilder = getDefaultMapRegisterBuilder();
         EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder();
-        etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc1)).build());
+        etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(rloc1).build());
         mapRegisterBuilder.setWantMapNotify(true);
-        etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
+        etlrBuilder.setLispAddressContainer(eid);
 
         EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
-        LispAFIAddress address = LispAFIConvertor.asIPAfiAddress("1.1.1.1");
-        etlr2Builder.setLispAddressContainer(LispAFIConvertor.toContainer(address));
+        LispAddressContainer address = LispAFIConvertor.asIPv4Address("1.1.1.1");
+        etlr2Builder.setLispAddressContainer(address);
         etlr2Builder.setMaskLength((short) 32);
         int recordTtl = 5;
         etlr2Builder.setRecordTtl(recordTtl);
@@ -520,15 +518,14 @@ public class MapServerTest extends BaseTestCase {
                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2"))).build());
         mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
         mapRegisterBuilder.getEidToLocatorRecord().add(etlr2Builder.build());
-        addDefaultPutAndGetExpectations(address, 32);
+        addDefaultPutAndGetExpectations(address);
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 
-        assertEquals(LispAFIConvertor.toContainer(rloc1), mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
+        assertEquals(rloc1, mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
                 .getLispAddressContainer());
         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2")), mapNotify.getEidToLocatorRecord().get(1)
                 .getLocatorRecord().get(0).getLispAddressContainer());
-        assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.1.1.1")), mapNotify.getEidToLocatorRecord().get(1)
-                .getLispAddressContainer());
+        assertEquals(address, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
         assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue());
 
     }
@@ -536,7 +533,7 @@ public class MapServerTest extends BaseTestCase {
     @Test
     public void handleMapRegisterIpv4__ChekWrongPassword() throws Exception {
 
-        addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 0, 31, "bla");
+        addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 31, "bla");
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
         assertEquals(null, mapNotify);
     }
@@ -544,8 +541,8 @@ public class MapServerTest extends BaseTestCase {
     @Test
     public void handleMapRegisterIpv4__ChcekNoPasswordAndThenPassword() throws Exception {
 
-        addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 25, "password");
-        addPutExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
+        addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 25, "password");
+        addPutExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
         assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
         assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
@@ -555,7 +552,7 @@ public class MapServerTest extends BaseTestCase {
     @Test
     public void handleMapRegisterIpv4__ChcekNoPassword() throws Exception {
 
-        addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 0, "password");
+        addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 30, 0, "password");
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
         assertEquals(null, mapNotify);
     }
@@ -563,7 +560,7 @@ public class MapServerTest extends BaseTestCase {
     @Test
     public void handleMapRegisterIpv4__ChcekNoreturn() throws Exception {
 
-        addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
+        addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
         assertEquals(mapNotify, null);
     }
@@ -572,81 +569,76 @@ public class MapServerTest extends BaseTestCase {
     @Test
     public void handleAddAuthenticationKey() throws Exception {
         String password = "pass";
-        IMappingKey key = getDefualtKey();
+        LispAddressContainer key = getDefaultKey();
         oneOf(lispDAO).put(weq(key),
-                weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), password)).toArray())));
-        testedMapServer.addAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask(), password);
+                weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(SubKeys.PASSWORD, password)).toArray())));
+        testedMapServer.addAuthenticationKey(eid, password);
     }
 
     @Test
     public void handleGetAuthenticationKey() throws Exception {
-        IMappingKey key = getDefualtKey();
-        oneOf(lispDAO).getSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
+        LispAddressContainer key = getDefaultKey();
+        oneOf(lispDAO).getSpecific(weq(key), with(SubKeys.PASSWORD));
         ret("password");
-        assertEquals("password", testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
+        assertEquals("password", testedMapServer.getAuthenticationKey(eid));
     }
 
     @Test
     public void handleGetAuthenticationKeyNoIteration() throws Exception {
         testedMapServer.setShouldIterateMask(false);
-        IMappingKey key = getDefualtKey();
-        IMappingKey passKey = getKey(30);
-        oneOf(lispDAO).getSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
-        allowing(lispDAO).getSpecific(weq(passKey), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
+        LispAddressContainer key = getDefaultKey();
+        LispAddressContainer passKey = getKey(30);
+        oneOf(lispDAO).getSpecific(weq(key), with(SubKeys.PASSWORD));
+        allowing(lispDAO).getSpecific(weq(passKey), with(SubKeys.PASSWORD));
         ret("password");
-        assertEquals(null, testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
+        assertEquals(null, testedMapServer.getAuthenticationKey(eid));
     }
 
     @Test
     public void handleRemoveAuthenticationKey() throws Exception {
-        IMappingKey key = getDefualtKey();
-        oneOf(lispDAO).removeSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
-        testedMapServer.removeAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask());
+        LispAddressContainer key = getDefaultKey();
+        oneOf(lispDAO).removeSpecific(weq(key), with(SubKeys.PASSWORD));
+        testedMapServer.removeAuthenticationKey(eid);
     }
 
-    private void addDefaultPutAndGetExpectations(LispAFIAddress addr, int mask) {
-        addPutExpectations(addr, mask);
-        addGetExpectations(addr, mask);
+    private void addDefaultPutAndGetExpectations(LispAddressContainer addr) {
+        addPutExpectations(addr);
+        addGetExpectations(addr);
     }
 
-    private void addGetExpectations(LispAFIAddress address, int mask) {
-        addGetExpectations(address, mask, 0, 0, "password");
+    private void addGetExpectations(LispAddressContainer address) {
+        addGetExpectations(address,  0, 0, SubKeys.PASSWORD);
     }
 
-    private void addPutExpectations(LispAFIAddress address, int mask) {
-        oneOf(lispDAO).put(weq(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), mask)),
-                with(mappingEntriesSaver));
+    private void addPutExpectations(LispAddressContainer address) {
+        exactly(2).of(lispDAO).put(weq(address), with(mappingEntriesSaver));
     }
 
-    private void addGetExpectations(LispAFIAddress address, int mask, int withoutPassword, int withPassword, String password) {
+    private void addGetExpectations(LispAddressContainer address, int withoutPassword, int withPassword, String password) {
         if (withoutPassword > 0) {
             String result = null;
             result = null;
-            allowing(lispDAO).getSpecific(
-                    with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password"));
+            allowing(lispDAO).getSpecific(with(address), with(SubKeys.PASSWORD));
             ret(result);
         }
         if (withPassword > 0) {
             String result = null;
             result = password;
-            allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withPassword)),
-                    with("password"));
+            allowing(lispDAO).getSpecific(with(address), with(SubKeys.PASSWORD));
             ret(result);
         }
-        for (int i = mask; i >= 0; i--) {
-            allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), i)),
-                    with("password"));
+        for (int i = MaskUtil.getMaskForAddress(address); i >= 0; i--) {
+            allowing(lispDAO).getSpecific(with(MaskUtil.normalize(address, (short) i)), with(SubKeys.PASSWORD));
             ret(null);
         }
     }
 
-    private IMappingKey getDefualtKey() {
+    private LispAddressContainer getDefaultKey() {
         return getKey(32);
     }
 
-    private IMappingKey getKey(int mask) {
-        IMappingKey key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(eid), mask);
-        return key;
+    private LispAddressContainer getKey(int mask) {
+        return MaskUtil.normalize(eid, (short)mask);
     }
 
     private MapRegisterBuilder getDefaultMapRegisterBuilder() {
OpenDaylight LISP Mapping Service