diff --git a/drivers/lisp/src/test/java/org/onosproject/drivers/lisp/extensions/LispExtensionMappingAddressInterpreterTest.java b/drivers/lisp/src/test/java/org/onosproject/drivers/lisp/extensions/LispExtensionMappingAddressInterpreterTest.java
new file mode 100644
index 0000000..7bfaab3
--- /dev/null
+++ b/drivers/lisp/src/test/java/org/onosproject/drivers/lisp/extensions/LispExtensionMappingAddressInterpreterTest.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright 2017-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.drivers.lisp.extensions;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.testing.EqualsTester;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onosproject.lisp.msg.types.LispAfiAddress;
+import org.onosproject.lisp.msg.types.LispIpv4Address;
+import org.onosproject.lisp.msg.types.LispIpv6Address;
+import org.onosproject.lisp.msg.types.lcaf.LispAppDataLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispAsLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispGeoCoordinateLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispListLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispMulticastLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispNatLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispNonceLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispSegmentLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispSourceDestLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispTeLcafAddress;
+import org.onosproject.lisp.msg.types.lcaf.LispTeRecord;
+import org.onosproject.mapping.addresses.ExtensionMappingAddress;
+import org.onosproject.mapping.addresses.ExtensionMappingAddressType;
+import org.onosproject.mapping.addresses.MappingAddress;
+import org.onosproject.mapping.addresses.MappingAddresses;
+
+import static org.junit.Assert.assertTrue;
+import static org.onosproject.mapping.addresses.ExtensionMappingAddressType.ExtensionMappingAddressTypes.*;
+/**
+ * Unit tests for LispExtensionMappingAddressInterpreter.
+ */
+public class LispExtensionMappingAddressInterpreterTest {
+
+    private static final String IPV4_STRING = "1.2.3.4";
+    private static final String IPV6_STRING = "1111:2222:3333:4444:5555:6666:7777:8886";
+    private static final IpPrefix IPV4_PREFIX = IpPrefix.valueOf(IPV4_STRING + "/32");
+    private static final IpPrefix IPV6_PREFIX = IpPrefix.valueOf(IPV6_STRING + "/128");
+    private static final IpAddress IPV4_ADDRESS = IpAddress.valueOf(IPV4_STRING);
+    private static final IpAddress IPV6_ADDRESS = IpAddress.valueOf(IPV6_STRING);
+
+    private static final int UNIQUE_INT = 1;
+    private static final short UNIQUE_SHORT = (short) 1;
+    private static final byte UNIQUE_BYTE = (byte) 1;
+    private static final boolean UNIQUE_BOOLEAN = true;
+
+    private LispExtensionMappingAddressInterpreter interpreter;
+    private ExtensionMappingAddress listExtAddress;
+    private ExtensionMappingAddress segmentExtAddress;
+    private ExtensionMappingAddress asExtAddress;
+    private ExtensionMappingAddress appDataExtAddress;
+    private ExtensionMappingAddress gcExtAddress;
+    private ExtensionMappingAddress natExtAddress;
+    private ExtensionMappingAddress nonceExtAddress;
+    private ExtensionMappingAddress multicastExtAddress;
+    private ExtensionMappingAddress teExtAddress;
+    private ExtensionMappingAddress srcDstExtAddress;
+
+    private LispLcafAddress listLcafAddress;
+    private LispLcafAddress segmentLcafAddress;
+    private LispLcafAddress asLcafAddress;
+    private LispLcafAddress appDataLcafAddress;
+    private LispLcafAddress gcLcafAddress;
+    private LispLcafAddress natLcafAddress;
+    private LispLcafAddress nonceLcafAddress;
+    private LispLcafAddress multicastLcafAddress;
+    private LispLcafAddress teLcafAddress;
+    private LispLcafAddress srcDstLcafAddress;
+
+    @Before
+    public void setUp() {
+        interpreter = new LispExtensionMappingAddressInterpreter();
+        initExtAddresses();
+        initLcafAddresses();
+    }
+
+    private void initExtAddresses() {
+        listExtAddress = getExtMappingAddress(LIST_ADDRESS.type());
+        segmentExtAddress = getExtMappingAddress(SEGMENT_ADDRESS.type());
+        asExtAddress = getExtMappingAddress(AS_ADDRESS.type());
+        appDataExtAddress = getExtMappingAddress(APPLICATION_DATA_ADDRESS.type());
+        gcExtAddress = getExtMappingAddress(GEO_COORDINATE_ADDRESS.type());
+        natExtAddress = getExtMappingAddress(NAT_ADDRESS.type());
+        nonceExtAddress = getExtMappingAddress(NONCE_ADDRESS.type());
+        multicastExtAddress = getExtMappingAddress(MULTICAST_ADDRESS.type());
+        teExtAddress = getExtMappingAddress(TRAFFIC_ENGINEERING_ADDRESS.type());
+        srcDstExtAddress = getExtMappingAddress(SOURCE_DEST_ADDRESS.type());
+    }
+
+    private void initLcafAddresses() {
+        listLcafAddress = getLcafMappingAddress(LIST_ADDRESS.type());
+        segmentLcafAddress = getLcafMappingAddress(SEGMENT_ADDRESS.type());
+        asLcafAddress = getLcafMappingAddress(AS_ADDRESS.type());
+        appDataLcafAddress = getLcafMappingAddress(APPLICATION_DATA_ADDRESS.type());
+        gcLcafAddress = getLcafMappingAddress(GEO_COORDINATE_ADDRESS.type());
+        natLcafAddress = getLcafMappingAddress(NAT_ADDRESS.type());
+        nonceLcafAddress = getLcafMappingAddress(NONCE_ADDRESS.type());
+        multicastLcafAddress = getLcafMappingAddress(MULTICAST_ADDRESS.type());
+        teLcafAddress = getLcafMappingAddress(TRAFFIC_ENGINEERING_ADDRESS.type());
+        srcDstLcafAddress = getLcafMappingAddress(SOURCE_DEST_ADDRESS.type());
+    }
+
+    @Test
+    public void testSupported() {
+        assertTrue("List extension address should be supported",
+                interpreter.supported(listExtAddress.type()));
+        assertTrue("Segment extension address should be supported",
+                interpreter.supported(segmentExtAddress.type()));
+        assertTrue("AS extension address should be supported",
+                interpreter.supported(asExtAddress.type()));
+        assertTrue("Application data extension address should be supported",
+                interpreter.supported(appDataExtAddress.type()));
+        assertTrue("Geo Coordinate extension address should be supported",
+                interpreter.supported(gcExtAddress.type()));
+        assertTrue("NAT extension address should be supported ",
+                interpreter.supported(natExtAddress.type()));
+        assertTrue("Nonce extension address should be supported",
+                interpreter.supported(nonceExtAddress.type()));
+        assertTrue("Multicast extension address should be supported",
+                interpreter.supported(multicastExtAddress.type()));
+        assertTrue("Traffic engineering extension address should be supported",
+                interpreter.supported(teExtAddress.type()));
+        assertTrue("Source Destination extension address should be supported",
+                interpreter.supported(srcDstExtAddress.type()));
+    }
+
+    @Test
+    public void testMapMappingAddress() {
+
+        new EqualsTester()
+                .addEqualityGroup(listLcafAddress, interpreter.mapMappingAddress(listExtAddress))
+                .addEqualityGroup(segmentLcafAddress, interpreter.mapMappingAddress(segmentExtAddress))
+                .addEqualityGroup(asLcafAddress, interpreter.mapMappingAddress(asExtAddress))
+                .addEqualityGroup(appDataLcafAddress, interpreter.mapMappingAddress(appDataExtAddress))
+                .addEqualityGroup(gcLcafAddress, interpreter.mapMappingAddress(gcExtAddress))
+                .addEqualityGroup(natLcafAddress, interpreter.mapMappingAddress(natExtAddress))
+                .addEqualityGroup(nonceLcafAddress, interpreter.mapMappingAddress(nonceExtAddress))
+                .addEqualityGroup(multicastLcafAddress, interpreter.mapMappingAddress(multicastExtAddress))
+                .addEqualityGroup(teLcafAddress, interpreter.mapMappingAddress(teExtAddress))
+                .addEqualityGroup(srcDstLcafAddress, interpreter.mapMappingAddress(srcDstExtAddress))
+                .testEquals();
+    }
+
+    @Test
+    public void testMapLcafAddress() {
+
+        new EqualsTester()
+                .addEqualityGroup(listExtAddress, interpreter.mapLcafAddress(listLcafAddress))
+                .addEqualityGroup(segmentExtAddress, interpreter.mapLcafAddress(segmentLcafAddress))
+                .addEqualityGroup(asExtAddress, interpreter.mapLcafAddress(asLcafAddress))
+                .addEqualityGroup(appDataExtAddress, interpreter.mapLcafAddress(appDataLcafAddress))
+                .addEqualityGroup(gcExtAddress, interpreter.mapLcafAddress(gcLcafAddress))
+                .addEqualityGroup(natExtAddress, interpreter.mapLcafAddress(natLcafAddress))
+                .addEqualityGroup(nonceExtAddress, interpreter.mapLcafAddress(nonceLcafAddress))
+                .addEqualityGroup(multicastExtAddress, interpreter.mapLcafAddress(multicastLcafAddress))
+                .addEqualityGroup(teExtAddress, interpreter.mapLcafAddress(teLcafAddress))
+                .addEqualityGroup(srcDstExtAddress, interpreter.mapLcafAddress(srcDstLcafAddress))
+                .testEquals();
+    }
+
+    private LispLcafAddress getLcafMappingAddress(ExtensionMappingAddressType type) {
+        LispLcafAddress address = null;
+
+        LispAfiAddress ipv4Addr = new LispIpv4Address(IPV4_ADDRESS);
+        LispAfiAddress ipv6Addr = new LispIpv6Address(IPV6_ADDRESS);
+
+        if (type.equals(LIST_ADDRESS.type())) {
+            address = new LispListLcafAddress(ImmutableList.of(ipv4Addr, ipv6Addr));
+        }
+
+        if (type.equals(SEGMENT_ADDRESS.type())) {
+            address = new LispSegmentLcafAddress.SegmentAddressBuilder()
+                                .withInstanceId(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(AS_ADDRESS.type())) {
+            address = new LispAsLcafAddress.AsAddressBuilder()
+                                .withAsNumber(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
+            address = new LispAppDataLcafAddress.AppDataAddressBuilder()
+                                .withProtocol(UNIQUE_BYTE)
+                                .withIpTos(UNIQUE_INT)
+                                .withLocalPortLow(UNIQUE_SHORT)
+                                .withLocalPortHigh(UNIQUE_SHORT)
+                                .withRemotePortLow(UNIQUE_SHORT)
+                                .withRemotePortHigh(UNIQUE_SHORT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
+            address = new LispGeoCoordinateLcafAddress.GeoCoordinateAddressBuilder()
+                                .withIsNorth(UNIQUE_BOOLEAN)
+                                .withLatitudeDegree(UNIQUE_SHORT)
+                                .withLatitudeMinute(UNIQUE_BYTE)
+                                .withLatitudeSecond(UNIQUE_BYTE)
+                                .withIsEast(UNIQUE_BOOLEAN)
+                                .withLongitudeDegree(UNIQUE_SHORT)
+                                .withLongitudeMinute(UNIQUE_BYTE)
+                                .withLongitudeSecond(UNIQUE_BYTE)
+                                .withAltitude(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(NAT_ADDRESS.type())) {
+            address = new LispNatLcafAddress.NatAddressBuilder()
+                                .withMsUdpPortNumber(UNIQUE_SHORT)
+                                .withEtrUdpPortNumber(UNIQUE_SHORT)
+                                .withGlobalEtrRlocAddress(ipv4Addr)
+                                .withMsRlocAddress(ipv4Addr)
+                                .withPrivateEtrRlocAddress(ipv4Addr)
+                                .withRtrRlocAddresses(ImmutableList.of(ipv4Addr, ipv6Addr))
+                                .build();
+        }
+
+        if (type.equals(NONCE_ADDRESS.type())) {
+            address = new LispNonceLcafAddress.NonceAddressBuilder()
+                                .withNonce(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(MULTICAST_ADDRESS.type())) {
+            address = new LispMulticastLcafAddress.MulticastAddressBuilder()
+                                .withInstanceId(UNIQUE_INT)
+                                .withSrcMaskLength(UNIQUE_BYTE)
+                                .withSrcAddress(ipv4Addr)
+                                .withGrpMaskLength(UNIQUE_BYTE)
+                                .withGrpAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
+            LispTeRecord tr = new LispTeRecord.TeRecordBuilder()
+                                .withIsLookup(UNIQUE_BOOLEAN)
+                                .withIsRlocProbe(UNIQUE_BOOLEAN)
+                                .withIsStrict(UNIQUE_BOOLEAN)
+                                .withRtrRlocAddress(ipv4Addr)
+                                .build();
+
+            address = new LispTeLcafAddress.TeAddressBuilder()
+                                .withTeRecords(ImmutableList.of(tr))
+                                .build();
+        }
+
+        if (type.equals(SOURCE_DEST_ADDRESS.type())) {
+            address = new LispSourceDestLcafAddress.SourceDestAddressBuilder()
+                                .withSrcMaskLength(UNIQUE_BYTE)
+                                .withSrcPrefix(ipv4Addr)
+                                .withDstMaskLength(UNIQUE_BYTE)
+                                .withDstPrefix(ipv4Addr)
+                                .build();
+        }
+
+        return address;
+    }
+
+    private ExtensionMappingAddress getExtMappingAddress(ExtensionMappingAddressType type) {
+
+        ExtensionMappingAddress address = null;
+
+        MappingAddress ipv4Addr = MappingAddresses.ipv4MappingAddress(IPV4_PREFIX);
+        MappingAddress ipv6Addr = MappingAddresses.ipv6MappingAddress(IPV6_PREFIX);
+
+        if (type.equals(LIST_ADDRESS.type())) {
+            address = new LispListAddress.Builder()
+                                .withIpv4(ipv4Addr)
+                                .withIpv6(ipv6Addr)
+                                .build();
+        }
+
+        if (type.equals(SEGMENT_ADDRESS.type())) {
+            address = new LispSegmentAddress.Builder()
+                                .withInstanceId(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(AS_ADDRESS.type())) {
+            address = new LispAsAddress.Builder()
+                                .withAsNumber(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
+            address = new LispAppDataAddress.Builder()
+                                .withProtocol(UNIQUE_BYTE)
+                                .withIpTos(UNIQUE_INT)
+                                .withLocalPortLow(UNIQUE_SHORT)
+                                .withLocalPortHigh(UNIQUE_SHORT)
+                                .withRemotePortLow(UNIQUE_SHORT)
+                                .withRemotePortHigh(UNIQUE_SHORT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
+            address = new LispGcAddress.Builder()
+                                .withIsNorth(UNIQUE_BOOLEAN)
+                                .withLatitudeDegree(UNIQUE_SHORT)
+                                .withLatitudeMinute(UNIQUE_BYTE)
+                                .withLatitudeSecond(UNIQUE_BYTE)
+                                .withIsEast(UNIQUE_BOOLEAN)
+                                .withLongitudeDegree(UNIQUE_SHORT)
+                                .withLongitudeMinute(UNIQUE_BYTE)
+                                .withLongitudeSecond(UNIQUE_BYTE)
+                                .withAltitude(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(NAT_ADDRESS.type())) {
+            address = new LispNatAddress.Builder()
+                                .withMsUdpPortNumber(UNIQUE_SHORT)
+                                .withEtrUdpPortNumber(UNIQUE_SHORT)
+                                .withGlobalEtrRlocAddress(ipv4Addr)
+                                .withMsRlocAddress(ipv4Addr)
+                                .withPrivateEtrRlocAddress(ipv4Addr)
+                                .withRtrRlocAddresses(ImmutableList.of(ipv4Addr, ipv6Addr))
+                                .build();
+        }
+
+        if (type.equals(NONCE_ADDRESS.type())) {
+            address = new LispNonceAddress.Builder()
+                                .withNonce(UNIQUE_INT)
+                                .withAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(MULTICAST_ADDRESS.type())) {
+            address = new LispMulticastAddress.Builder()
+                                .withInstanceId(UNIQUE_INT)
+                                .withSrcMaskLength(UNIQUE_BYTE)
+                                .withSrcAddress(ipv4Addr)
+                                .withGrpMaskLength(UNIQUE_BYTE)
+                                .withGrpAddress(ipv4Addr)
+                                .build();
+        }
+
+        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
+
+            LispTeAddress.TeRecord tr = new LispTeAddress.TeRecord.Builder()
+                                .withIsLookup(UNIQUE_BOOLEAN)
+                                .withIsRlocProbe(UNIQUE_BOOLEAN)
+                                .withIsStrict(UNIQUE_BOOLEAN)
+                                .withRtrRlocAddress(ipv4Addr)
+                                .build();
+
+            address = new LispTeAddress.Builder()
+                                .withTeRecords(ImmutableList.of(tr))
+                                .build();
+        }
+
+        if (type.equals(SOURCE_DEST_ADDRESS.type())) {
+            address = new LispSrcDstAddress.Builder()
+                                .withSrcMaskLength(UNIQUE_BYTE)
+                                .withSrcPrefix(ipv4Addr)
+                                .withDstMaskLength(UNIQUE_BYTE)
+                                .withDstPrefix(ipv4Addr)
+                                .build();
+        }
+        return address;
+    }
+}