Post split cleanup

- change groupIds
- change packages
- update poms

Change-Id: I343c5a292a67de1dd50687870ca4ab5b7276e93e
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>
Signed-off-by: Marek Gradzki <mgradzki@cisco.com>

34 files changed, 5118 insertions, 0 deletions

diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AclCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AclCustomizerTest.java
new file mode 100644
index 000000000..7f55ae60a
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/AclCustomizerTest.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import io.fd.hc2vpp.v3po.interfaces.acl.ingress.AclCustomizer;
+import io.fd.hc2vpp.v3po.vppclassifier.VppClassifierContextManager;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterface;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterfaceReply;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.acl.base.attributes.L2Acl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.acl.base.attributes.L2AclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Acl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.acl.Ingress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.acl.IngressBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class AclCustomizerTest extends WriterCustomizerTest {
+
+    @Mock
+    private VppClassifierContextManager classifyTableContext;
+
+    private AclCustomizer customizer;
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String IF_NAME = "local0";
+    private static final int IF_INDEX = 1;
+
+    private static final int ACL_TABLE_INDEX = 0;
+    private static final String ACL_TABLE_NAME = "table0";
+
+    @Override
+    public void setUp() {
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+        customizer = new AclCustomizer(api, new NamingContext("generatedInterfaceName", IFC_TEST_INSTANCE),
+            classifyTableContext);
+    }
+
+    private InstanceIdentifier<Ingress> getAclId(final String name) {
+        return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(name)).augmentation(
+            VppInterfaceAugmentation.class).child(Acl.class).child(Ingress.class);
+    }
+
+    private Ingress generateAcl(final String tableName) {
+        final IngressBuilder builder = new IngressBuilder();
+        final L2Acl l2Acl = new L2AclBuilder().setClassifyTable(tableName).build();
+        builder.setL2Acl(l2Acl);
+        return builder.build();
+    }
+
+    private void whenInputAclSetInterfaceThenSuccess() {
+        doReturn(future(new InputAclSetInterfaceReply())).when(api)
+            .inputAclSetInterface(any(InputAclSetInterface.class));
+    }
+
+    private void whenInputAclSetInterfaceThenFailure() {
+        doReturn(failedFuture()).when(api).inputAclSetInterface(any(InputAclSetInterface.class));
+    }
+
+    private static InputAclSetInterface generateInputAclSetInterface(final byte isAdd, final int ifIndex,
+                                                                     final int l2TableIndex) {
+        final InputAclSetInterface request = new InputAclSetInterface();
+        request.isAdd = isAdd;
+        request.l2TableIndex = l2TableIndex;
+        request.ip4TableIndex = ~0;
+        request.ip6TableIndex = ~0;
+        request.swIfIndex = ifIndex;
+        return request;
+    }
+
+    @Test
+    public void testCreate() throws Exception {
+        final Ingress acl = generateAcl(ACL_TABLE_NAME);
+        final InstanceIdentifier<Ingress> id = getAclId(IF_NAME);
+
+        whenInputAclSetInterfaceThenSuccess();
+
+        customizer.writeCurrentAttributes(id, acl, writeContext);
+
+        verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 1, IF_INDEX, ACL_TABLE_INDEX));
+    }
+
+    @Test
+    public void testCreateFailed() throws Exception {
+        final Ingress acl = generateAcl(ACL_TABLE_NAME);
+        final InstanceIdentifier<Ingress> id = getAclId(IF_NAME);
+
+        whenInputAclSetInterfaceThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(id, acl, writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 1, IF_INDEX, ACL_TABLE_INDEX));
+            return;
+        }
+        fail("WriteFailedException.CreateFailedException was expected");
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        final Ingress acl = generateAcl(ACL_TABLE_NAME);
+        final InstanceIdentifier<Ingress> id = getAclId(IF_NAME);
+
+        whenInputAclSetInterfaceThenSuccess();
+
+        customizer.deleteCurrentAttributes(id, acl, writeContext);
+
+        verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 0, IF_INDEX, ACL_TABLE_INDEX));
+    }
+
+    @Test
+    public void testDeleteFailed() throws Exception {
+        final Ingress acl = generateAcl(ACL_TABLE_NAME);
+        final InstanceIdentifier<Ingress> id = getAclId(IF_NAME);
+
+        whenInputAclSetInterfaceThenFailure();
+
+        try {
+            customizer.deleteCurrentAttributes(id, acl, writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).inputAclSetInterface(generateInputAclSetInterface((byte) 0, IF_INDEX, ACL_TABLE_INDEX));
+            return;
+        }
+        fail("WriteFailedException.DeleteFailedException was expected");
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/GreCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/GreCustomizerTest.java
new file mode 100644
index 000000000..da75fa92d
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/GreCustomizerTest.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.net.InetAddresses;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+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.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Gre;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.GreBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.VppInvocationException;
+import io.fd.vpp.jvpp.core.dto.GreAddDelTunnel;
+import io.fd.vpp.jvpp.core.dto.GreAddDelTunnelReply;
+
+public class GreCustomizerTest extends WriterCustomizerTest {
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private final String IFACE_NAME = "eth0";
+    private final int IFACE_ID = 1;
+    private InstanceIdentifier<Gre> id = InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME))
+        .augmentation(VppInterfaceAugmentation.class).child(Gre.class);
+    private static final byte ADD_GRE = 1;
+    private static final byte DEL_GRE = 0;
+
+    private GreCustomizer customizer;
+
+    @Override
+    public void setUp() throws Exception {
+        InterfaceTypeTestUtils.setupWriteContext(writeContext,
+            org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.GreTunnel.class);
+        customizer = new GreCustomizer(api, new NamingContext("generateInterfaceNAme", IFC_TEST_INSTANCE));
+    }
+
+    private void whenGreAddDelTunnelThenSuccess() {
+        final GreAddDelTunnelReply reply = new GreAddDelTunnelReply();
+        reply.swIfIndex = IFACE_ID;
+        doReturn(future(reply)).when(api).greAddDelTunnel(any(GreAddDelTunnel.class));
+    }
+
+    private void whenGreAddDelTunnelThenFailure() {
+        doReturn(failedFuture()).when(api).greAddDelTunnel(any(GreAddDelTunnel.class));
+    }
+
+    private GreAddDelTunnel verifyGreAddDelTunnelWasInvoked(final Gre gre) throws VppInvocationException {
+        ArgumentCaptor<GreAddDelTunnel> argumentCaptor = ArgumentCaptor.forClass(GreAddDelTunnel.class);
+        verify(api).greAddDelTunnel(argumentCaptor.capture());
+        final GreAddDelTunnel actual = argumentCaptor.getValue();
+        assertEquals(0, actual.isIpv6);
+        assertArrayEquals(InetAddresses.forString(gre.getSrc().getIpv4Address().getValue()).getAddress(),
+                actual.srcAddress);
+        assertArrayEquals(InetAddresses.forString(gre.getDst().getIpv4Address().getValue()).getAddress(),
+                actual.dstAddress);
+        assertEquals(gre.getOuterFibId().intValue(), actual.outerFibId);
+        return actual;
+    }
+
+    private void verifyGreAddWasInvoked(final Gre gre) throws VppInvocationException {
+        final GreAddDelTunnel actual = verifyGreAddDelTunnelWasInvoked(gre);
+        assertEquals(ADD_GRE, actual.isAdd);
+    }
+
+    private void verifyGreDeleteWasInvoked(final Gre gre) throws VppInvocationException {
+        final GreAddDelTunnel actual = verifyGreAddDelTunnelWasInvoked(gre);
+        assertEquals(DEL_GRE, actual.isAdd);
+    }
+
+    private static Gre generateGre() {
+        final GreBuilder builder = new GreBuilder();
+        builder.setSrc(new IpAddress(new Ipv4Address("192.168.20.10")));
+        builder.setDst(new IpAddress(new Ipv4Address("192.168.20.11")));
+        builder.setOuterFibId(Long.valueOf(123));
+        return builder.build();
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws Exception {
+        final Gre gre = generateGre();
+
+        whenGreAddDelTunnelThenSuccess();
+
+        noMappingDefined(mappingContext, IFACE_NAME, IFC_TEST_INSTANCE);
+
+        customizer.writeCurrentAttributes(id, gre, writeContext);
+        verifyGreAddWasInvoked(gre);
+        verify(mappingContext).put(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE)),
+            eq(mapping(IFACE_NAME, IFACE_ID).get()));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesMappingAlreadyPresent() throws Exception {
+        final Gre gre = generateGre();
+
+        whenGreAddDelTunnelThenSuccess();
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_TEST_INSTANCE);
+
+        customizer.writeCurrentAttributes(id, gre, writeContext);
+        verifyGreAddWasInvoked(gre);
+
+        // Remove the first mapping before putting in the new one
+        verify(mappingContext).delete(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE)));
+        verify(mappingContext).put(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE)), eq(mapping(IFACE_NAME, IFACE_ID).get()));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesFailed() throws Exception {
+        final Gre gre = generateGre();
+
+        whenGreAddDelTunnelThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(id, gre, writeContext);
+        } catch (WriteFailedException.CreateFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyGreAddWasInvoked(gre);
+            // Mapping not stored due to failure
+            verify(mappingContext, times(0)).put(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE)), eq(mapping(
+                IFACE_NAME, 0).get()));
+            return;
+        }
+        fail("WriteFailedException.CreateFailedException was expected");
+    }
+
+    @Test
+    public void testUpdateCurrentAttributes() throws Exception {
+        try {
+            customizer.updateCurrentAttributes(id, generateGre(), generateGre(), writeContext);
+        } catch (WriteFailedException.UpdateFailedException e) {
+            assertEquals(UnsupportedOperationException.class, e.getCause().getClass());
+            return;
+        }
+        fail("WriteFailedException.UpdateFailedException was expected");
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws Exception {
+        final Gre gre = generateGre();
+
+        whenGreAddDelTunnelThenSuccess();
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_TEST_INSTANCE);
+
+        customizer.deleteCurrentAttributes(id, gre, writeContext);
+        verifyGreDeleteWasInvoked(gre);
+        verify(mappingContext).delete(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE)));
+    }
+
+    @Test
+    public void testDeleteCurrentAttributesaFailed() throws Exception {
+        final Gre gre = generateGre();
+
+        whenGreAddDelTunnelThenFailure();
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_TEST_INSTANCE);
+
+        try {
+            customizer.deleteCurrentAttributes(id, gre, writeContext);
+        } catch (WriteFailedException.DeleteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyGreDeleteWasInvoked(gre);
+            verify(mappingContext, times(0)).delete(eq(mappingIid(IFACE_NAME, IFC_TEST_INSTANCE)));
+            return;
+        }
+        fail("WriteFailedException.DeleteFailedException was expected");
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceCustomizerTest.java
new file mode 100644
index 000000000..c72d43a02
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceCustomizerTest.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetFlags;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetFlagsReply;
+
+public class InterfaceCustomizerTest extends WriterCustomizerTest implements ByteDataTranslator {
+    private static final String IFACE_CTX_NAME = "interface-ctx";
+    private static final String IF_NAME = "eth1";
+    private static final int IF_INDEX = 1;
+
+    private InterfaceCustomizer customizer;
+    private InstanceIdentifier<Interface> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME));
+
+    @Override
+    protected void setUp() throws Exception {
+        customizer = new InterfaceCustomizer(api, new NamingContext("ifacePrefix", IFACE_CTX_NAME));
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFACE_CTX_NAME);
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        final boolean enabled = true;
+        when(api.swInterfaceSetFlags(any())).thenReturn(future(new SwInterfaceSetFlagsReply()));
+        customizer.writeCurrentAttributes(IID, iface(enabled), writeContext);
+        verify(api).swInterfaceSetFlags(expectedRequest(enabled));
+    }
+
+    @Test
+    public void testWriteFailed() {
+        final boolean enabled = false;
+        when(api.swInterfaceSetFlags(any())).thenReturn(failedFuture());
+        try {
+            customizer.writeCurrentAttributes(IID, iface(enabled), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceSetFlags(expectedRequest(enabled));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+
+    @Test
+    public void testUpdate() throws WriteFailedException {
+        when(api.swInterfaceSetFlags(any())).thenReturn(future(new SwInterfaceSetFlagsReply()));
+        customizer.updateCurrentAttributes(IID, iface(false), iface(true), writeContext);
+        verify(api).swInterfaceSetFlags(expectedRequest(true));
+    }
+
+    @Test
+    public void testUpdateFailed() {
+        when(api.swInterfaceSetFlags(any())).thenReturn(failedFuture());
+        try {
+            customizer.updateCurrentAttributes(IID, iface(false), iface(true), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceSetFlags(expectedRequest(true));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        customizer.deleteCurrentAttributes(IID, mock(Interface.class), writeContext);
+        verifyZeroInteractions(api);
+    }
+
+    private Interface iface(final boolean enabled) {
+        return new InterfaceBuilder().setName(IF_NAME).setEnabled(enabled).build();
+    }
+
+    private SwInterfaceSetFlags expectedRequest(final boolean enabled) {
+        final SwInterfaceSetFlags request = new SwInterfaceSetFlags();
+        request.deleted = 0;
+        request.adminUpDown = booleanToByte(enabled);
+        request.linkUpDown = booleanToByte(enabled);
+        request.swIfIndex = IF_INDEX;
+        return request;
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceTypeTestUtils.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceTypeTestUtils.java
new file mode 100644
index 000000000..5bce6aea1
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/InterfaceTypeTestUtils.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.mockito.Mockito.doReturn;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.write.WriteContext;
+import org.mockito.Matchers;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+final class InterfaceTypeTestUtils {
+
+    private InterfaceTypeTestUtils() {}
+
+    static void setupWriteContext(final WriteContext writeContext, final Class<? extends InterfaceType> ifcType) {
+        doReturn(new ModificationCache()).when(writeContext).getModificationCache();
+        doReturn(Optional.of(new InterfaceBuilder()
+            .setType(ifcType)
+            .build())).when(writeContext).readAfter(Matchers.any(InstanceIdentifier.class));
+    }
+
+}
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/L2CustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/L2CustomizerTest.java
new file mode 100644
index 000000000..d54bd3392
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/L2CustomizerTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.L2;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.L2Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.l2.base.attributes.Interconnection;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.l2.base.attributes.interconnection.BridgeBased;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.l2.base.attributes.interconnection.BridgeBasedBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.l2.base.attributes.interconnection.XconnectBased;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.l2.base.attributes.interconnection.XconnectBasedBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2Bridge;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2BridgeReply;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2Xconnect;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2XconnectReply;
+
+public class L2CustomizerTest extends WriterCustomizerTest implements ByteDataTranslator {
+    private static final String IFACE_CTX_NAME = "interface-ctx";
+    private static final String BD_CTX_NAME = "bd-ctx";
+    private static final String IF1_NAME = "eth1";
+    private static final int IF1_INDEX = 1;
+    private static final String IF2_NAME = "eth2";
+    private static final int IF2_INDEX = 2;
+    private static final InstanceIdentifier<L2> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF1_NAME))
+            .augmentation(VppInterfaceAugmentation.class).child(L2.class);
+    private static final String BD_NAME = "test_bd";
+    private static final int BD_INDEX = 13;
+
+    private L2Customizer customizer;
+
+    @Override
+    protected void setUp() throws Exception {
+        customizer = new L2Customizer(api, new NamingContext("ifacePrefix", IFACE_CTX_NAME),
+            new NamingContext("bdPrefix", BD_CTX_NAME));
+        defineMapping(mappingContext, IF1_NAME, IF1_INDEX, IFACE_CTX_NAME);
+        defineMapping(mappingContext, IF2_NAME, IF2_INDEX, IFACE_CTX_NAME);
+        defineMapping(mappingContext, BD_NAME, BD_INDEX, BD_CTX_NAME);
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        when(api.swInterfaceSetL2Xconnect(any())).thenReturn(future(new SwInterfaceSetL2XconnectReply()));
+        customizer.writeCurrentAttributes(IID, l2(xconnectBased()), writeContext);
+        verify(api).swInterfaceSetL2Xconnect(xconnectRequest(true));
+    }
+
+    @Test
+    public void testWriteFailed() {
+        when(api.swInterfaceSetL2Bridge(any())).thenReturn(failedFuture());
+        try {
+            customizer.writeCurrentAttributes(IID, l2(bridgeBased(false)), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceSetL2Bridge(bridgeRequest(false, true));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+
+    @Test
+    public void testUpdate() throws WriteFailedException {
+        when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply()));
+        customizer.updateCurrentAttributes(IID, l2(bridgeBased(false)), l2(bridgeBased(true)), writeContext);
+        verify(api).swInterfaceSetL2Bridge(bridgeRequest(true, true));
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        when(api.swInterfaceSetL2Xconnect(any())).thenReturn(future(new SwInterfaceSetL2XconnectReply()));
+        customizer.deleteCurrentAttributes(IID, l2(xconnectBased()), writeContext);
+        verify(api).swInterfaceSetL2Xconnect(xconnectRequest(false));
+    }
+
+    @Test
+    public void testDeleteFailed() {
+        when(api.swInterfaceSetL2Bridge(any())).thenReturn(failedFuture());
+        try {
+            customizer.deleteCurrentAttributes(IID, l2(bridgeBased(true)), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceSetL2Bridge(bridgeRequest(true, false));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+
+    private XconnectBased xconnectBased() {
+        return new XconnectBasedBuilder().setXconnectOutgoingInterface(IF2_NAME).build();
+    }
+
+    private SwInterfaceSetL2Xconnect xconnectRequest(final boolean enable) {
+        final SwInterfaceSetL2Xconnect request = new SwInterfaceSetL2Xconnect();
+        request.rxSwIfIndex = IF1_INDEX;
+        request.txSwIfIndex = IF2_INDEX;
+        request.enable = booleanToByte(enable);
+        return request;
+    }
+
+    private BridgeBased bridgeBased(final boolean bvi) {
+        return new BridgeBasedBuilder().setBridgedVirtualInterface(bvi)
+            .setBridgeDomain(BD_NAME).setSplitHorizonGroup((short) 123).build();
+    }
+
+    private SwInterfaceSetL2Bridge bridgeRequest(final boolean bvi, final boolean enable) {
+        final SwInterfaceSetL2Bridge request = new SwInterfaceSetL2Bridge();
+        request.bdId = BD_INDEX;
+        request.rxSwIfIndex = IF1_INDEX;
+        request.bvi = booleanToByte(bvi);
+        request.enable = booleanToByte(enable);
+        request.shg = 123;
+        return request;
+    }
+
+
+    private L2 l2(final Interconnection interconnection) {
+        return new L2Builder().setInterconnection(interconnection).build();
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/LoopbackCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/LoopbackCustomizerTest.java
new file mode 100644
index 000000000..67c90343e
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/LoopbackCustomizerTest.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.core.dto.CreateLoopback;
+import io.fd.vpp.jvpp.core.dto.CreateLoopbackReply;
+import io.fd.vpp.jvpp.core.dto.DeleteLoopback;
+import io.fd.vpp.jvpp.core.dto.DeleteLoopbackReply;
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Loopback;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.LoopbackBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class LoopbackCustomizerTest extends WriterCustomizerTest {
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private LoopbackCustomizer loopCustomizer;
+
+    @Override
+    public void setUp() throws Exception {
+        InterfaceTypeTestUtils.setupWriteContext(writeContext,
+            org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.Loopback.class);
+        loopCustomizer = new LoopbackCustomizer(api, new NamingContext("ifcintest", IFC_TEST_INSTANCE));
+    }
+
+    @Test
+    public void testCreate() throws Exception {
+        doAnswer(new Answer() {
+
+            int idx = 0;
+
+            @Override
+            public Object answer(final InvocationOnMock invocation) throws Throwable {
+                final CreateLoopbackReply t = new CreateLoopbackReply();
+                t.swIfIndex = idx++;
+                return future(t);
+            }
+        }).when(api).createLoopback(any(CreateLoopback.class));
+
+        loopCustomizer.writeCurrentAttributes(getLoopbackId("loop"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext);
+        loopCustomizer.writeCurrentAttributes(getLoopbackId("loop2"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext);
+
+        verify(api, times(2)).createLoopback(any(CreateLoopback.class));
+        verify(mappingContext).put(eq(mappingIid("loop", IFC_TEST_INSTANCE)), eq(
+                mapping("loop", 0).get()));
+        verify(mappingContext).put(eq(mappingIid("loop2", IFC_TEST_INSTANCE)), eq(
+                mapping("loop2", 1).get()));
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        final CreateLoopbackReply t = new CreateLoopbackReply();
+        t.swIfIndex = 0;
+        doReturn(future(t)).when(api).createLoopback(any(CreateLoopback.class));
+
+        doReturn(future(new DeleteLoopbackReply())).when(api).deleteLoopback(any(DeleteLoopback.class));
+
+        loopCustomizer.writeCurrentAttributes(getLoopbackId("loop"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext);
+        defineMapping(mappingContext, "loop", 1, IFC_TEST_INSTANCE);
+        loopCustomizer.deleteCurrentAttributes(getLoopbackId("loop"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext);
+
+        verify(api).createLoopback(any(CreateLoopback.class));
+        verify(api).deleteLoopback(any(DeleteLoopback.class));
+        verify(mappingContext).delete(eq(mappingIid("loop", IFC_TEST_INSTANCE)));
+    }
+
+    private InstanceIdentifier<Loopback> getLoopbackId(final String loop) {
+        return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(loop)).augmentation(
+            VppInterfaceAugmentation.class).child(Loopback.class);
+    }
+
+    private Loopback getLoopbackData(final String mac) {
+        return new LoopbackBuilder().setMac(new PhysAddress(mac)).build();
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ProxyArpCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ProxyArpCustomizerTest.java
new file mode 100644
index 000000000..232d62e9e
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ProxyArpCustomizerTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ProxyArp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ProxyArpBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.core.dto.ProxyArpAddDel;
+import io.fd.vpp.jvpp.core.dto.ProxyArpAddDelReply;
+
+public class ProxyArpCustomizerTest extends WriterCustomizerTest implements ByteDataTranslator {
+    private static final String IF_NAME = "eth1";
+
+    private ProxyArpCustomizer customizer;
+
+    @Override
+    public void setUp() throws Exception {
+        customizer = new ProxyArpCustomizer(api);
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        when(api.proxyArpAddDel(any())).thenReturn(future(new ProxyArpAddDelReply()));
+        customizer.writeCurrentAttributes(getProxyArpId(IF_NAME), proxyArp(), writeContext);
+        verify(api).proxyArpAddDel(expectedRequest(true));
+    }
+
+    @Test(expected = WriteFailedException.class)
+    public void testWriteFailed() throws WriteFailedException {
+        when(api.proxyArpAddDel(any())).thenReturn(failedFuture());
+        customizer.writeCurrentAttributes(getProxyArpId(IF_NAME), proxyArp(), writeContext);
+    }
+
+    @Test(expected = WriteFailedException.UpdateFailedException.class)
+    public void testUpdate() throws WriteFailedException.UpdateFailedException {
+        customizer.updateCurrentAttributes(getProxyArpId(IF_NAME), proxyArp(), proxyArp(), writeContext);
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        when(api.proxyArpAddDel(any())).thenReturn(future(new ProxyArpAddDelReply()));
+        customizer.deleteCurrentAttributes(getProxyArpId(IF_NAME), proxyArp(), writeContext);
+        verify(api).proxyArpAddDel(expectedRequest(false));
+    }
+
+    @Test(expected = WriteFailedException.DeleteFailedException.class)
+    public void testDeleteFailed() throws WriteFailedException {
+        when(api.proxyArpAddDel(any())).thenReturn(failedFuture());
+        customizer.deleteCurrentAttributes(getProxyArpId(IF_NAME), proxyArp(), writeContext);
+    }
+
+    private ProxyArp proxyArp() {
+        return new ProxyArpBuilder().setVrfId(123L).setHighAddr(new Ipv4AddressNoZone("10.1.1.2"))
+            .setLowAddr(new Ipv4AddressNoZone("10.1.1.1")).build();
+    }
+
+    private ProxyArpAddDel expectedRequest(final boolean isAdd) {
+        final ProxyArpAddDel request = new ProxyArpAddDel();
+        request.isAdd = booleanToByte(isAdd);
+        request.vrfId = 123;
+        request.lowAddress = new byte[]{10,1,1,1};
+        request.hiAddress = new byte[]{10,1,1,2};
+        return request;
+    }
+
+    private InstanceIdentifier<ProxyArp> getProxyArpId(final String eth0) {
+        return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(eth0)).augmentation(
+            VppInterfaceAugmentation.class).child(ProxyArp.class);
+    }
+}
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/RewriteCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/RewriteCustomizerTest.java
new file mode 100644
index 000000000..fa9914233
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/RewriteCustomizerTest.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.common.translate.util.TagRewriteOperation;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.VppInvocationException;
+import io.fd.vpp.jvpp.core.dto.L2InterfaceVlanTagRewrite;
+import io.fd.vpp.jvpp.core.dto.L2InterfaceVlanTagRewriteReply;
+import org.junit.Assert;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.SubinterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214._802dot1q;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.l2.Rewrite;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.l2.RewriteBuilder;
+import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class RewriteCustomizerTest extends WriterCustomizerTest {
+
+    private NamingContext namingContext;
+    private RewriteCustomizer customizer;
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String IF_NAME = "local0";
+    private static final String VLAN_IF_NAME = "local0.1";
+    private static final int VLAN_IF_ID = 1;
+    private static final int VLAN_IF_INDEX = 11;
+    private InstanceIdentifier<Rewrite> VLAN_IID;
+
+    @Override
+    public void setUp() throws Exception {
+        namingContext = new NamingContext("generatedSubInterfaceName", IFC_TEST_INSTANCE);
+        customizer = new RewriteCustomizer(api, namingContext);
+        VLAN_IID = getVlanTagRewriteId(IF_NAME, VLAN_IF_ID);
+        defineMapping(mappingContext, VLAN_IF_NAME, VLAN_IF_INDEX, IFC_TEST_INSTANCE);
+    }
+
+    private static InstanceIdentifier<Rewrite> getVlanTagRewriteId(final String name, final long index) {
+        final Class<ChildOf<? super SubInterface>> child = (Class) Rewrite.class;
+        final InstanceIdentifier id =
+                InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(name)).augmentation(
+                        SubinterfaceAugmentation.class).child(SubInterfaces.class)
+                        .child(SubInterface.class, new SubInterfaceKey(index))
+                        .child(child);
+        return id;
+    }
+
+    private Rewrite generateRewrite(final TagRewriteOperation op) {
+        final RewriteBuilder builder = new RewriteBuilder();
+        builder.setPopTags((short) op.getPopTags());
+        builder.setVlanType(_802dot1q.class);
+        return builder.build();
+    }
+
+    private L2InterfaceVlanTagRewrite generateL2InterfaceVlanTagRewrite(final int swIfIndex,
+                                                                        final TagRewriteOperation op) {
+        final L2InterfaceVlanTagRewrite request = new L2InterfaceVlanTagRewrite();
+        request.swIfIndex = swIfIndex;
+        request.vtrOp = op.ordinal();
+        request.pushDot1Q = 1;
+        return request;
+    }
+
+    /**
+     * Positive response
+     */
+    private void whenL2InterfaceVlanTagRewriteThenSuccess() {
+        doReturn(future(new L2InterfaceVlanTagRewriteReply())).when(api)
+                .l2InterfaceVlanTagRewrite(any(L2InterfaceVlanTagRewrite.class));
+    }
+
+    /**
+     * Failure response send
+     */
+    private void whenL2InterfaceVlanTagRewriteThenFailure() {
+        doReturn(failedFuture()).when(api).l2InterfaceVlanTagRewrite(any(L2InterfaceVlanTagRewrite.class));
+    }
+
+    private void verifyL2InterfaceVlanTagRewriteDeleteWasInvoked() throws VppInvocationException {
+        final L2InterfaceVlanTagRewrite request = new L2InterfaceVlanTagRewrite();
+        request.swIfIndex = VLAN_IF_INDEX;
+        verify(api).l2InterfaceVlanTagRewrite(request);
+    }
+
+    @Test
+    public void testCreate() throws Exception {
+        final TagRewriteOperation op = TagRewriteOperation.pop_2;
+        final Rewrite vlanTagRewrite = generateRewrite(op);
+
+        whenL2InterfaceVlanTagRewriteThenSuccess();
+
+        customizer.writeCurrentAttributes(VLAN_IID, vlanTagRewrite, writeContext);
+
+        verify(api).l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op));
+    }
+
+    @Test
+    public void testCreateFailed() throws Exception {
+        final TagRewriteOperation op = TagRewriteOperation.pop_2;
+        final Rewrite vlanTagRewrite = generateRewrite(op);
+
+        whenL2InterfaceVlanTagRewriteThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(VLAN_IID, vlanTagRewrite, writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, op));
+            return;
+        }
+        fail("WriteFailedException.CreateFailedException was expected");
+    }
+
+    @Test
+    public void testUpdate() throws Exception {
+        final Rewrite before = generateRewrite(TagRewriteOperation.pop_2);
+        final Rewrite after = generateRewrite(TagRewriteOperation.pop_1);
+
+        whenL2InterfaceVlanTagRewriteThenSuccess();
+
+        customizer.updateCurrentAttributes(VLAN_IID, before, after, writeContext);
+
+        verify(api)
+                .l2InterfaceVlanTagRewrite(generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, TagRewriteOperation.pop_1));
+    }
+
+    @Test
+    public void testUpdateFailed() throws Exception {
+        final Rewrite before = generateRewrite(TagRewriteOperation.pop_2);
+        final Rewrite after = generateRewrite(TagRewriteOperation.pop_1);
+
+        whenL2InterfaceVlanTagRewriteThenFailure();
+
+        try {
+            customizer.updateCurrentAttributes(VLAN_IID, before, after, writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api)
+                    .l2InterfaceVlanTagRewrite(
+                            generateL2InterfaceVlanTagRewrite(VLAN_IF_INDEX, TagRewriteOperation.pop_1));
+            return;
+        }
+        fail("WriteFailedException.UpdateFailedException was expected");
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        whenL2InterfaceVlanTagRewriteThenSuccess();
+
+        customizer.deleteCurrentAttributes(VLAN_IID, null, writeContext);
+
+        verifyL2InterfaceVlanTagRewriteDeleteWasInvoked();
+    }
+
+    @Test
+    public void testDeleteFailed() throws Exception {
+        whenL2InterfaceVlanTagRewriteThenFailure();
+
+        try {
+            customizer.deleteCurrentAttributes(VLAN_IID, null, writeContext);
+        } catch (WriteFailedException e) {
+            Assert.assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyL2InterfaceVlanTagRewriteDeleteWasInvoked();
+            return;
+        }
+        fail("WriteFailedException.DeleteFailedException was expected");
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/RoutingCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/RoutingCustomizerTest.java
new file mode 100644
index 000000000..a61cd149b
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/RoutingCustomizerTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetTable;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetTableReply;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Routing;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.RoutingBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class RoutingCustomizerTest extends WriterCustomizerTest {
+    private static final String IFACE_CTX_NAME = "interface-ctx";
+    private static final String IF_NAME = "eth1";
+    private static final int IF_INDEX = 1;
+    private static final InstanceIdentifier<Routing> IID =
+            InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME))
+                    .augmentation(VppInterfaceAugmentation.class).child(Routing.class);
+
+    private RoutingCustomizer customizer;
+
+    @Override
+    protected void setUp() throws Exception {
+        customizer = new RoutingCustomizer(api, new NamingContext("ifacePrefix", IFACE_CTX_NAME));
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFACE_CTX_NAME);
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        final int vrfId = 123;
+        when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply()));
+        customizer.writeCurrentAttributes(IID, routing(vrfId), writeContext);
+        verify(api).swInterfaceSetTable(expectedRequest(vrfId));
+    }
+
+    @Test(expected = WriteFailedException.class)
+    public void testWriteFailed() throws WriteFailedException {
+        when(api.swInterfaceSetTable(any())).thenReturn(failedFuture());
+        customizer.writeCurrentAttributes(IID, routing(213), writeContext);
+    }
+
+    @Test(expected = WriteFailedException.class)
+    public void testUpdateFailed() throws WriteFailedException {
+        when(api.swInterfaceSetTable(any())).thenReturn(failedFuture());
+        customizer.updateCurrentAttributes(IID, routing(123L), routing(321L), writeContext);
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply()));
+        customizer.deleteCurrentAttributes(IID, routing(123), writeContext);
+        verify(api).swInterfaceSetTable(expectedRequest(0));
+    }
+
+    @Test(expected = WriteFailedException.DeleteFailedException.class)
+    public void testDeleteFailed() throws WriteFailedException {
+        when(api.swInterfaceSetTable(any())).thenReturn(failedFuture());
+        customizer.deleteCurrentAttributes(IID, routing(123), writeContext);
+    }
+
+    private Routing routing(final long vrfId) {
+        return new RoutingBuilder().setIpv4VrfId(vrfId).build();
+    }
+
+    private SwInterfaceSetTable expectedRequest(final int vrfId) {
+        final SwInterfaceSetTable request = new SwInterfaceSetTable();
+        request.isIpv6 = 0;
+        request.swIfIndex = IF_INDEX;
+        request.vrfId = vrfId;
+        return request;
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizerTest.java
new file mode 100644
index 000000000..fd71a8015
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceCustomizerTest.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.CVlan;
+import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.Dot1qTagVlanType;
+import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.Dot1qVlanId;
+import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.SVlan;
+import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.dot1q.tag.or.any.Dot1qTag;
+import org.opendaylight.yang.gen.v1.urn.ieee.params.xml.ns.yang.dot1q.types.rev150626.dot1q.tag.or.any.Dot1qTagBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.SubinterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214._802dot1ad;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.match.attributes.match.type.vlan.tagged.VlanTaggedBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.MatchBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.TagsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.tags.Tag;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.tags.TagBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.tags.TagKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.CreateSubif;
+import io.fd.vpp.jvpp.core.dto.CreateSubifReply;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetFlags;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetFlagsReply;
+
+public class SubInterfaceCustomizerTest extends WriterCustomizerTest {
+
+    private NamingContext namingContext;
+    private SubInterfaceCustomizer customizer;
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String SUPER_IF_NAME = "local0";
+    private static final int SUPER_IF_ID = 1;
+    private static final String SUB_IFACE_NAME = "local0.11";
+    private static final int SUBIF_INDEX = 11;
+
+    private static final short STAG_ID = 100;
+    private static final short CTAG_ID = 200;
+    private static final short CTAG_ANY_ID = 0; // only the *IdAny flag is set
+
+    private final Tag STAG_100;
+    private final Tag CTAG_200;
+    private final Tag CTAG_ANY;
+
+    public SubInterfaceCustomizerTest() {
+        STAG_100 = generateTag((short) 0, SVlan.class, new Dot1qTag.VlanId(new Dot1qVlanId((int) STAG_ID)));
+        CTAG_200 = generateTag((short) 1, CVlan.class, new Dot1qTag.VlanId(new Dot1qVlanId(200)));
+        CTAG_ANY = generateTag((short) 1, CVlan.class, new Dot1qTag.VlanId(Dot1qTag.VlanId.Enumeration.Any));
+    }
+
+    @Override
+    public void setUp() throws Exception {
+        namingContext = new NamingContext("generatedSubInterfaceName", IFC_TEST_INSTANCE);
+        customizer = new SubInterfaceCustomizer(api, namingContext);
+        defineMapping(mappingContext, SUB_IFACE_NAME, SUBIF_INDEX, IFC_TEST_INSTANCE);
+        defineMapping(mappingContext, SUPER_IF_NAME, SUPER_IF_ID, IFC_TEST_INSTANCE);
+    }
+
+    private SubInterface generateSubInterface(final boolean enabled, final List<Tag> tagList) {
+        SubInterfaceBuilder builder = new SubInterfaceBuilder();
+        builder.setVlanType(_802dot1ad.class);
+        builder.setIdentifier(11L);
+        final TagsBuilder tags = new TagsBuilder();
+
+        tags.setTag(tagList);
+
+        builder.setTags(tags.build());
+
+        builder.setMatch(generateMatch());
+        builder.setEnabled(enabled);
+        return builder.build();
+    }
+
+    private static Tag generateTag(final short index, final Class<? extends Dot1qTagVlanType> tagType,
+                                   final Dot1qTag.VlanId vlanId) {
+        TagBuilder tag = new TagBuilder();
+        tag.setIndex(index);
+        tag.setKey(new TagKey(index));
+        final Dot1qTagBuilder dtag = new Dot1qTagBuilder();
+        dtag.setTagType(tagType);
+        dtag.setVlanId(vlanId);
+        tag.setDot1qTag(dtag.build());
+        return tag.build();
+    }
+
+    private static Match generateMatch() {
+        final MatchBuilder match = new MatchBuilder();
+        final VlanTaggedBuilder tagged = new VlanTaggedBuilder();
+        tagged.setMatchExactTags(true);
+        match.setMatchType(
+            new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.match.attributes.match.type.VlanTaggedBuilder()
+                .setVlanTagged(tagged.build()).build());
+        return match.build();
+    }
+
+    private CreateSubif generateSubInterfaceRequest(final int superIfId, final short innerVlanId,
+                                                    final boolean isInnerAny) {
+        CreateSubif request = new CreateSubif();
+        request.subId = 11;
+        request.swIfIndex = superIfId;
+        request.twoTags = 1;
+        request.innerVlanId = innerVlanId;
+        request.innerVlanIdAny = (byte) (isInnerAny
+            ? 1
+            : 0);
+        request.dot1Ad = 1;
+        request.outerVlanId = STAG_ID;
+        return request;
+    }
+
+    private SwInterfaceSetFlags generateSwInterfaceEnableRequest(final int swIfIndex) {
+        SwInterfaceSetFlags request = new SwInterfaceSetFlags();
+        request.swIfIndex = swIfIndex;
+        request.adminUpDown = 1;
+        return request;
+    }
+
+    private InstanceIdentifier<SubInterface> getSubInterfaceId(final String name, final long index) {
+        return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(name)).augmentation(
+            SubinterfaceAugmentation.class).child(SubInterfaces.class)
+            .child(SubInterface.class, new SubInterfaceKey(index));
+    }
+
+    private void whenCreateSubifThenSuccess() {
+        doReturn(future(new CreateSubifReply())).when(api).createSubif(any(CreateSubif.class));
+    }
+
+    /**
+     * Failure response send
+     */
+    private void whenCreateSubifThenFailure() {
+        doReturn(failedFuture()).when(api).createSubif(any(CreateSubif.class));
+    }
+
+    private void whenSwInterfaceSetFlagsThenSuccess() {
+        doReturn(future(new SwInterfaceSetFlagsReply())).when(api).swInterfaceSetFlags(any(SwInterfaceSetFlags.class));
+    }
+
+    private SwInterfaceSetFlags verifySwInterfaceSetFlagsWasInvoked(final SwInterfaceSetFlags expected)
+        throws VppBaseCallException {
+        ArgumentCaptor<SwInterfaceSetFlags> argumentCaptor = ArgumentCaptor.forClass(SwInterfaceSetFlags.class);
+        verify(api).swInterfaceSetFlags(argumentCaptor.capture());
+        final SwInterfaceSetFlags actual = argumentCaptor.getValue();
+
+        assertEquals(expected.swIfIndex, actual.swIfIndex);
+        assertEquals(expected.adminUpDown, actual.adminUpDown);
+        return actual;
+    }
+
+    @Test
+    public void testCreateTwoTags() throws Exception {
+        final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_200));
+        final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX);
+
+        whenCreateSubifThenSuccess();
+        whenSwInterfaceSetFlagsThenSuccess();
+
+        customizer.writeCurrentAttributes(id, subInterface, writeContext);
+
+        verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false));
+        verify(mappingContext)
+            .put(eq(mappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq(
+                mapping(SUB_IFACE_NAME, 0).get()));
+    }
+
+    @Test
+    public void testCreateDot1qAnyTag() throws Exception {
+        final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_ANY));
+        final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX);
+
+        whenCreateSubifThenSuccess();
+        whenSwInterfaceSetFlagsThenSuccess();
+
+        customizer.writeCurrentAttributes(id, subInterface, writeContext);
+
+        verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ANY_ID, true));
+        verify(mappingContext)
+            .put(eq(mappingIid(SUB_IFACE_NAME, IFC_TEST_INSTANCE)), eq(
+                mapping(SUB_IFACE_NAME, 0).get()));
+    }
+
+    @Test
+    public void testCreateFailed() throws Exception {
+        final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_200));
+        final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX);
+
+        whenCreateSubifThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(id, subInterface, writeContext);
+        } catch (WriteFailedException.CreateFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).createSubif(generateSubInterfaceRequest(SUPER_IF_ID, CTAG_ID, false));
+            verify(mappingContext, times(0)).put(
+                eq(mappingIid(SUPER_IF_NAME, IFC_TEST_INSTANCE)),
+                eq(mapping(SUPER_IF_NAME, 0).get()));
+            return;
+        }
+        fail("WriteFailedException.CreateFailedException was expected");
+    }
+
+    @Test
+    public void testUpdate() throws Exception {
+        final List<Tag> tags = Arrays.asList(STAG_100, CTAG_200);
+        final SubInterface before = generateSubInterface(false, tags);
+        final SubInterface after = generateSubInterface(true, tags);
+        final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX);
+
+        whenSwInterfaceSetFlagsThenSuccess();
+        customizer.updateCurrentAttributes(id, before, after, writeContext);
+
+        verifySwInterfaceSetFlagsWasInvoked(generateSwInterfaceEnableRequest(SUBIF_INDEX));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testDelete() throws Exception {
+        final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_200));
+        customizer.deleteCurrentAttributes(null, subInterface, writeContext);
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceL2CustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceL2CustomizerTest.java
new file mode 100644
index 000000000..29b1b0d99
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/SubInterfaceL2CustomizerTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.l2.base.attributes.interconnection.BridgeBasedBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.SubinterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.L2;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.L2Builder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2Bridge;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceSetL2BridgeReply;
+
+public class SubInterfaceL2CustomizerTest extends WriterCustomizerTest implements ByteDataTranslator {
+    private static final String IFACE_CTX_NAME = "interface-ctx";
+    private static final String IF_NAME = "local0";
+    private static final int IF_INDEX = 1;
+    private static final String SUBIF_NAME = "local0.0";
+    private static final int SUBIF_INDEX = 11;
+    private static final long SUBIF_ID = 0;
+
+    private static final InstanceIdentifier<L2> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)).augmentation(
+            SubinterfaceAugmentation.class).child(SubInterfaces.class)
+            .child(SubInterface.class, new SubInterfaceKey(SUBIF_ID)).child(L2.class);
+
+
+    private static final String BD_CTX_NAME = "bd-ctx";
+    private static final String BD_NAME = "test_bd";
+    private static final int BD_INDEX = 13;
+
+    private SubInterfaceL2Customizer customizer;
+
+    @Override
+    protected void setUp() throws Exception {
+        customizer = new SubInterfaceL2Customizer(api, new NamingContext("ifacePrefix", IFACE_CTX_NAME),
+            new NamingContext("bdPrefix", BD_CTX_NAME));
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFACE_CTX_NAME);
+        defineMapping(mappingContext, SUBIF_NAME, SUBIF_INDEX, IFACE_CTX_NAME);
+        defineMapping(mappingContext, BD_NAME, BD_INDEX, BD_CTX_NAME);
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        final boolean bvi = true;
+        when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply()));
+        customizer.writeCurrentAttributes(IID, l2(bvi), writeContext);
+        verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, true));
+    }
+
+    @Test
+    public void testUpdate() throws WriteFailedException {
+        final boolean bvi = false;
+        when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply()));
+        customizer.updateCurrentAttributes(IID, l2(true), l2(bvi), writeContext);
+        verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, true));
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        final boolean bvi = true;
+        when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply()));
+        customizer.deleteCurrentAttributes(IID, l2(bvi), writeContext);
+        verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, false));
+    }
+
+    private L2 l2(final boolean bvi) {
+        return new L2Builder().setInterconnection(new BridgeBasedBuilder().setBridgedVirtualInterface(bvi)
+            .setBridgeDomain(BD_NAME).setSplitHorizonGroup((short) 123).build()).build();
+    }
+
+    private SwInterfaceSetL2Bridge bridgeRequest(final boolean bvi, final boolean enable) {
+        final SwInterfaceSetL2Bridge request = new SwInterfaceSetL2Bridge();
+        request.bdId = BD_INDEX;
+        request.rxSwIfIndex = SUBIF_INDEX;
+        request.bvi = booleanToByte(bvi);
+        request.enable = booleanToByte(enable);
+        request.shg = 123;
+        return request;
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/TapCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/TapCustomizerTest.java
new file mode 100644
index 000000000..f55859ace
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/TapCustomizerTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Tap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.TapBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.core.dto.TapConnect;
+import io.fd.vpp.jvpp.core.dto.TapConnectReply;
+import io.fd.vpp.jvpp.core.dto.TapDelete;
+import io.fd.vpp.jvpp.core.dto.TapDeleteReply;
+import io.fd.vpp.jvpp.core.dto.TapModify;
+import io.fd.vpp.jvpp.core.dto.TapModifyReply;
+
+public class TapCustomizerTest extends WriterCustomizerTest {
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private TapCustomizer tapCustomizer;
+
+    @Override
+    public void setUp() throws Exception {
+        InterfaceTypeTestUtils.setupWriteContext(writeContext,
+            org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.Tap.class);
+        tapCustomizer = new TapCustomizer(api, new NamingContext("ifcintest", IFC_TEST_INSTANCE));
+    }
+
+    @Test
+    public void testCreate() throws Exception {
+        doAnswer(new Answer() {
+
+            int idx = 0;
+
+            @Override
+            public Object answer(final InvocationOnMock invocation) throws Throwable {
+                final TapConnectReply t = new TapConnectReply();
+                t.swIfIndex = idx++;
+                return future(t);
+            }
+        }).when(api).tapConnect(any(TapConnect.class));
+
+        tapCustomizer.writeCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
+        tapCustomizer.writeCurrentAttributes(getTapId("tap2"), getTapData("tap2", "ff:ff:ff:ff:ff:ff"), writeContext);
+
+        verify(api, times(2)).tapConnect(any(TapConnect.class));
+        verify(mappingContext).put(eq(mappingIid("tap", IFC_TEST_INSTANCE)), eq(
+                mapping("tap", 0).get()));
+        verify(mappingContext).put(eq(mappingIid("tap2", IFC_TEST_INSTANCE)), eq(
+                mapping("tap2", 1).get()));
+    }
+
+    @Test
+    public void testModify() throws Exception {
+        final TapConnectReply t = new TapConnectReply();
+        t.swIfIndex = 0;
+        doReturn(future(t)).when(api).tapConnect(any(TapConnect.class));
+
+        final TapModifyReply tmodif = new TapModifyReply();
+        tmodif.swIfIndex = 0;
+        doReturn(future(tmodif)).when(api).tapModify(any(TapModify.class));
+
+        tapCustomizer.writeCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
+
+        defineMapping(mappingContext, "tap", 1, IFC_TEST_INSTANCE);
+        tapCustomizer.updateCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), getTapData("tap", "ff:ff:ff:ff:ff:f1"), writeContext);
+
+        verify(api).tapConnect(any(TapConnect.class));
+        verify(api).tapModify(any(TapModify.class));
+
+        verify(mappingContext).put(eq(mappingIid("tap", IFC_TEST_INSTANCE)), eq(
+                mapping("tap", 0).get()));
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        final TapConnectReply t = new TapConnectReply();
+        t.swIfIndex = 0;
+        doReturn(future(t)).when(api).tapConnect(any(TapConnect.class));
+
+        doReturn(future(new TapDeleteReply())).when(api).tapDelete(any(TapDelete.class));
+
+        tapCustomizer.writeCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
+        defineMapping(mappingContext, "tap", 1, IFC_TEST_INSTANCE);
+        tapCustomizer.deleteCurrentAttributes(getTapId("tap"), getTapData("tap", "ff:ff:ff:ff:ff:ff"), writeContext);
+
+        verify(api).tapConnect(any(TapConnect.class));
+        verify(api).tapDelete(any(TapDelete.class));
+        verify(mappingContext).delete(eq(mappingIid("tap", IFC_TEST_INSTANCE)));
+    }
+
+    private InstanceIdentifier<Tap> getTapId(final String tap) {
+        return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(tap)).augmentation(
+            VppInterfaceAugmentation.class).child(Tap.class);
+    }
+
+    private Tap getTapData(final String tap, final String mac) {
+        return new TapBuilder().setTapName(tap).setMac(new PhysAddress(mac)).build();
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizerTest.java
new file mode 100644
index 000000000..4f8b7a6d4
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VhostUserCustomizerTest.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+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.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.VhostUser;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.VhostUserBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.VppInvocationException;
+import io.fd.vpp.jvpp.core.dto.CreateVhostUserIf;
+import io.fd.vpp.jvpp.core.dto.CreateVhostUserIfReply;
+import io.fd.vpp.jvpp.core.dto.DeleteVhostUserIf;
+import io.fd.vpp.jvpp.core.dto.DeleteVhostUserIfReply;
+import io.fd.vpp.jvpp.core.dto.ModifyVhostUserIf;
+import io.fd.vpp.jvpp.core.dto.ModifyVhostUserIfReply;
+
+public class VhostUserCustomizerTest extends WriterCustomizerTest implements Ipv4Translator {
+
+    private VhostUserCustomizer customizer;
+    private static final int IFACE_ID = 1;
+    private static final String IFACE_NAME = "eth0";
+    private static final InstanceIdentifier<VhostUser> ID =
+            InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME))
+                    .augmentation(VppInterfaceAugmentation.class).child(VhostUser.class);
+
+    @Override
+    public void setUp() throws Exception {
+        InterfaceTypeTestUtils.setupWriteContext(writeContext,
+                org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUser.class);
+        customizer = new VhostUserCustomizer(api, new NamingContext("generatedInterfaceName", "test-instance"));
+    }
+
+    private CreateVhostUserIf verifyCreateVhostUserIfWasInvoked(final VhostUser vhostUser)
+            throws VppInvocationException {
+        ArgumentCaptor<CreateVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(CreateVhostUserIf.class);
+        verify(api).createVhostUserIf(argumentCaptor.capture());
+        final CreateVhostUserIf actual = argumentCaptor.getValue();
+        assertEquals(0, actual.customDevInstance);
+
+        assertEquals(booleanToByte(VhostUserRole.Server.equals(vhostUser.getRole())), actual.isServer);
+        assertEquals(0, actual.renumber);
+        assertEquals(0, actual.useCustomMac);
+        assertArrayEquals(vhostUser.getSocket().getBytes(), actual.sockFilename);
+        assertNotNull(actual.macAddress);
+        return actual;
+    }
+
+    private ModifyVhostUserIf verifyModifyVhostUserIfWasInvoked(final VhostUser vhostUser, final int swIfIndex)
+            throws VppInvocationException {
+        ArgumentCaptor<ModifyVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(ModifyVhostUserIf.class);
+        verify(api).modifyVhostUserIf(argumentCaptor.capture());
+        final ModifyVhostUserIf actual = argumentCaptor.getValue();
+        assertEquals(0, actual.customDevInstance);
+
+        assertEquals(booleanToByte(VhostUserRole.Server.equals(vhostUser.getRole())), actual.isServer);
+        assertEquals(0, actual.renumber);
+        assertEquals(swIfIndex, actual.swIfIndex);
+        assertArrayEquals(vhostUser.getSocket().getBytes(), actual.sockFilename);
+        return actual;
+    }
+
+    private DeleteVhostUserIf verifyDeleteVhostUserIfWasInvoked(final int swIfIndex) throws VppInvocationException {
+        ArgumentCaptor<DeleteVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(DeleteVhostUserIf.class);
+        verify(api).deleteVhostUserIf(argumentCaptor.capture());
+        final DeleteVhostUserIf actual = argumentCaptor.getValue();
+        assertEquals(swIfIndex, actual.swIfIndex);
+        return actual;
+    }
+
+    private static VhostUser generateVhostUser(final VhostUserRole role, final String socketName) {
+        VhostUserBuilder builder = new VhostUserBuilder();
+        builder.setRole(role);
+        builder.setSocket(socketName);
+        return builder.build();
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws Exception {
+        final VhostUser vhostUser = generateVhostUser(VhostUserRole.Server, "socketName");
+
+        when(api.createVhostUserIf(any(CreateVhostUserIf.class))).thenReturn(future(new CreateVhostUserIfReply()));
+
+        customizer.writeCurrentAttributes(ID, vhostUser, writeContext);
+        verifyCreateVhostUserIfWasInvoked(vhostUser);
+        verify(mappingContext).put(eq(mappingIid(IFACE_NAME, "test-instance")), eq(
+            mapping(IFACE_NAME, 0).get()));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesFailed() throws Exception {
+        final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName");
+
+        doReturn(failedFuture()).when(api).createVhostUserIf(any(CreateVhostUserIf.class));
+
+        try {
+            customizer.writeCurrentAttributes(ID, vhostUser, writeContext);
+        } catch (WriteFailedException.CreateFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyCreateVhostUserIfWasInvoked(vhostUser);
+            verifyZeroInteractions(mappingContext);
+            return;
+        }
+        fail("WriteFailedException.CreateFailedException was expected");
+    }
+
+    @Test
+    public void testUpdateCurrentAttributes() throws Exception {
+        final VhostUser vhostUserBefore = generateVhostUser(VhostUserRole.Client, "socketName0");
+        final VhostUser vhostUserAfter = generateVhostUser(VhostUserRole.Server, "socketName1");
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
+
+        when(api.modifyVhostUserIf(any(ModifyVhostUserIf.class))).thenReturn(future(new ModifyVhostUserIfReply()));
+
+        customizer.updateCurrentAttributes(ID, vhostUserBefore, vhostUserAfter, writeContext);
+        verifyModifyVhostUserIfWasInvoked(vhostUserAfter, IFACE_ID);
+    }
+
+    @Test
+    public void testUpdateCurrentAttributesFailed() throws Exception {
+        final VhostUser vhostUserBefore = generateVhostUser(VhostUserRole.Client, "socketName0");
+        final VhostUser vhostUserAfter = generateVhostUser(VhostUserRole.Server, "socketName1");
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
+
+        doReturn(failedFuture()).when(api).modifyVhostUserIf(any(ModifyVhostUserIf.class));
+
+        try {
+            customizer.updateCurrentAttributes(ID, vhostUserBefore, vhostUserAfter, writeContext);
+        } catch (WriteFailedException.UpdateFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyModifyVhostUserIfWasInvoked(vhostUserAfter, IFACE_ID);
+            return;
+        }
+        fail("WriteFailedException.UpdateFailedException was expected");
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws Exception {
+        final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName");
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
+
+        when(api.deleteVhostUserIf(any(DeleteVhostUserIf.class))).thenReturn(future(new DeleteVhostUserIfReply()));
+
+        customizer.deleteCurrentAttributes(ID, vhostUser, writeContext);
+        verifyDeleteVhostUserIfWasInvoked(IFACE_ID);
+        verify(mappingContext).delete(eq(mappingIid(IFACE_NAME, "test-instance")));
+    }
+
+    @Test
+    public void testDeleteCurrentAttributesFailed() throws Exception {
+        final VhostUser vhostUser = generateVhostUser(VhostUserRole.Client, "socketName");
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, "test-instance");
+
+        doReturn(failedFuture()).when(api).deleteVhostUserIf(any(DeleteVhostUserIf.class));
+
+        try {
+            customizer.deleteCurrentAttributes(ID, vhostUser, writeContext);
+        } catch (WriteFailedException.DeleteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyDeleteVhostUserIfWasInvoked(IFACE_ID);
+            // Delete from context not invoked if delete from VPP failed
+            verify(mappingContext, times(0)).delete(eq(mappingIid(IFACE_NAME, "test-instance")));
+            verify(mappingContext).read(eq(mappingIid(IFACE_NAME, "test-instance")));
+            return;
+        }
+        fail("WriteFailedException.DeleteFailedException was expected");
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanCustomizerTest.java
new file mode 100644
index 000000000..f5b6873de
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanCustomizerTest.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.net.InetAddresses;
+import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+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.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Vxlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.VxlanBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.VppInvocationException;
+import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnel;
+import io.fd.vpp.jvpp.core.dto.VxlanAddDelTunnelReply;
+
+public class VxlanCustomizerTest extends WriterCustomizerTest {
+
+    private static final byte ADD_VXLAN = 1;
+    private static final byte DEL_VXLAN = 0;
+
+    @Mock
+    private DisabledInterfacesManager disableContext;
+
+    private VxlanCustomizer customizer;
+    private String ifaceName;
+    private InstanceIdentifier<Vxlan> id;
+
+    @Override
+    public void setUp() throws Exception {
+        InterfaceTypeTestUtils.setupWriteContext(writeContext,
+            org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanTunnel.class);
+
+        customizer =
+            new VxlanCustomizer(api, new NamingContext("generateInterfaceNAme", "test-instance"), disableContext);
+
+        ifaceName = "eth0";
+        id = InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(ifaceName))
+            .augmentation(VppInterfaceAugmentation.class).child(Vxlan.class);
+    }
+
+    private void whenVxlanAddDelTunnelThenSuccess() {
+        when(api.vxlanAddDelTunnel(any(VxlanAddDelTunnel.class))).thenReturn(future(new VxlanAddDelTunnelReply()));
+    }
+
+    private void whenVxlanAddDelTunnelThenFailure() {
+        doReturn(failedFuture()).when(api).vxlanAddDelTunnel(any(VxlanAddDelTunnel.class));
+    }
+
+    private VxlanAddDelTunnel verifyVxlanAddDelTunnelWasInvoked(final Vxlan vxlan) throws VppInvocationException {
+        ArgumentCaptor<VxlanAddDelTunnel> argumentCaptor = ArgumentCaptor.forClass(VxlanAddDelTunnel.class);
+        verify(api).vxlanAddDelTunnel(argumentCaptor.capture());
+        final VxlanAddDelTunnel actual = argumentCaptor.getValue();
+        assertEquals(0, actual.isIpv6);
+        assertEquals(-1, actual.decapNextIndex);
+        assertArrayEquals(InetAddresses.forString(vxlan.getSrc().getIpv4Address().getValue()).getAddress(),
+            actual.srcAddress);
+        assertArrayEquals(InetAddresses.forString(vxlan.getDst().getIpv4Address().getValue()).getAddress(),
+            actual.dstAddress);
+        assertEquals(vxlan.getEncapVrfId().intValue(), actual.encapVrfId);
+        assertEquals(vxlan.getVni().getValue().intValue(), actual.vni);
+        return actual;
+    }
+
+    private void verifyVxlanAddWasInvoked(final Vxlan vxlan) throws VppInvocationException {
+        final VxlanAddDelTunnel actual = verifyVxlanAddDelTunnelWasInvoked(vxlan);
+        assertEquals(ADD_VXLAN, actual.isAdd);
+    }
+
+    private void verifyVxlanDeleteWasInvoked(final Vxlan vxlan) throws VppInvocationException {
+        final VxlanAddDelTunnel actual = verifyVxlanAddDelTunnelWasInvoked(vxlan);
+        assertEquals(DEL_VXLAN, actual.isAdd);
+    }
+
+    private static Vxlan generateVxlan(long vni) {
+        final VxlanBuilder builder = new VxlanBuilder();
+        builder.setSrc(new IpAddress(new Ipv4Address("192.168.20.10")));
+        builder.setDst(new IpAddress(new Ipv4Address("192.168.20.11")));
+        builder.setEncapVrfId(Long.valueOf(123));
+        builder.setVni(new VxlanVni(Long.valueOf(vni)));
+        return builder.build();
+    }
+
+    private static Vxlan generateVxlan() {
+        return generateVxlan(Long.valueOf(11));
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws Exception {
+        final Vxlan vxlan = generateVxlan();
+
+        whenVxlanAddDelTunnelThenSuccess();
+        noMappingDefined(mappingContext, ifaceName, "test-instance");
+
+        customizer.writeCurrentAttributes(id, vxlan, writeContext);
+        verifyVxlanAddWasInvoked(vxlan);
+        verify(mappingContext).put(eq(mappingIid(ifaceName, "test-instance")), eq(mapping(ifaceName, 0).get()));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesWithExistingVxlanPlaceholder() throws Exception {
+        final Vxlan vxlan = generateVxlan();
+
+        whenVxlanAddDelTunnelThenSuccess();
+        noMappingDefined(mappingContext, ifaceName, "test-instance");
+        doReturn(true).when(disableContext).isInterfaceDisabled(0, mappingContext);
+
+        customizer.writeCurrentAttributes(id, vxlan, writeContext);
+        verifyVxlanAddWasInvoked(vxlan);
+        verify(mappingContext).put(eq(mappingIid(ifaceName, "test-instance")), eq(mapping(ifaceName, 0).get()));
+        verify(disableContext).removeDisabledInterface(0, mappingContext);
+    }
+
+    @Test
+    public void testWriteCurrentAttributesMappingAlreadyPresent() throws Exception {
+        final Vxlan vxlan = generateVxlan();
+        final int ifaceId = 0;
+
+        whenVxlanAddDelTunnelThenSuccess();
+        defineMapping(mappingContext, ifaceName, ifaceId, "test-instance");
+
+        customizer.writeCurrentAttributes(id, vxlan, writeContext);
+        verifyVxlanAddWasInvoked(vxlan);
+
+        // Remove the first mapping before putting in the new one
+        verify(mappingContext).delete(eq(mappingIid(ifaceName, "test-instance")));
+        verify(mappingContext)
+            .put(eq(mappingIid(ifaceName, "test-instance")), eq(mapping(ifaceName, ifaceId).get()));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesFailed() throws Exception {
+        final Vxlan vxlan = generateVxlan();
+
+        whenVxlanAddDelTunnelThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(id, vxlan, writeContext);
+        } catch (WriteFailedException.CreateFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyVxlanAddWasInvoked(vxlan);
+            // Mapping not stored due to failure
+            verify(mappingContext, times(0))
+                .put(eq(mappingIid(ifaceName, "test-instance")), eq(mapping(ifaceName, 0).get()));
+            return;
+        }
+        fail("WriteFailedException.CreateFailedException was expected");
+    }
+
+    @Test
+    public void testUpdateCurrentAttributes() throws Exception {
+        try {
+            customizer.updateCurrentAttributes(id, generateVxlan(10), generateVxlan(11), writeContext);
+        } catch (WriteFailedException.UpdateFailedException e) {
+            assertEquals(UnsupportedOperationException.class, e.getCause().getClass());
+            return;
+        }
+        fail("WriteFailedException.UpdateFailedException was expected");
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws Exception {
+        final Vxlan vxlan = generateVxlan();
+
+        whenVxlanAddDelTunnelThenSuccess();
+        defineMapping(mappingContext, ifaceName, 1, "test-instance");
+
+        customizer.deleteCurrentAttributes(id, vxlan, writeContext);
+        verifyVxlanDeleteWasInvoked(vxlan);
+        verify(mappingContext).delete(eq(mappingIid(ifaceName, "test-instance")));
+        verify(disableContext).disableInterface(1, mappingContext);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributesaFailed() throws Exception {
+        final Vxlan vxlan = generateVxlan();
+
+        whenVxlanAddDelTunnelThenFailure();
+        defineMapping(mappingContext, ifaceName, 1, "test-instance");
+
+        try {
+            customizer.deleteCurrentAttributes(id, vxlan, writeContext);
+        } catch (WriteFailedException.DeleteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyVxlanDeleteWasInvoked(vxlan);
+            verify(mappingContext, times(0)).delete(eq(mappingIid(ifaceName, "test-instance")));
+            return;
+        }
+        fail("WriteFailedException.DeleteFailedException was expected");
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeCustomizerTest.java
new file mode 100644
index 000000000..7337c16e3
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/VxlanGpeCustomizerTest.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.net.InetAddresses;
+import io.fd.hc2vpp.v3po.DisabledInterfacesManager;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+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.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanGpeNextProtocol;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanGpeVni;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.VxlanGpe;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.VxlanGpeBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.VxlanGpeAddDelTunnel;
+import io.fd.vpp.jvpp.core.dto.VxlanGpeAddDelTunnelReply;
+
+public class VxlanGpeCustomizerTest extends WriterCustomizerTest {
+
+    private static final byte ADD_VXLAN_GPE = 1;
+    private static final byte DEL_VXLAN_GPE = 0;
+
+    @Mock
+    private DisabledInterfacesManager interfaceDisableContext;
+
+    private VxlanGpeCustomizer customizer;
+    private String ifaceName;
+    private InstanceIdentifier<VxlanGpe> id;
+
+    @Override
+    public void setUp() throws Exception {
+        InterfaceTypeTestUtils.setupWriteContext(writeContext,
+            org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanGpeTunnel.class);
+        NamingContext namingContext = new NamingContext("generateInterfaceName", "test-instance");
+        customizer = new VxlanGpeCustomizer(api, namingContext, interfaceDisableContext);
+
+        ifaceName = "elth0";
+        id = InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(ifaceName))
+            .augmentation(VppInterfaceAugmentation.class).child(VxlanGpe.class);
+    }
+
+    private void whenVxlanGpeAddDelTunnelThenSuccess() {
+        when(api.vxlanGpeAddDelTunnel(any(VxlanGpeAddDelTunnel.class)))
+            .thenReturn(future(new VxlanGpeAddDelTunnelReply()));
+    }
+
+    private void whenVxlanGpeAddDelTunnelThenFailure() {
+        doReturn(failedFuture()).when(api).vxlanGpeAddDelTunnel(any(VxlanGpeAddDelTunnel.class));
+    }
+
+    private VxlanGpeAddDelTunnel verifyVxlanGpeAddDelTunnelWasInvoked(final VxlanGpe vxlanGpe)
+        throws VppBaseCallException {
+        ArgumentCaptor<VxlanGpeAddDelTunnel> argumentCaptor = ArgumentCaptor.forClass(VxlanGpeAddDelTunnel.class);
+        verify(api).vxlanGpeAddDelTunnel(argumentCaptor.capture());
+        final VxlanGpeAddDelTunnel actual = argumentCaptor.getValue();
+        assertEquals(0, actual.isIpv6);
+        assertArrayEquals(InetAddresses.forString(vxlanGpe.getLocal().getIpv4Address().getValue()).getAddress(),
+            actual.local);
+        assertArrayEquals(InetAddresses.forString(vxlanGpe.getRemote().getIpv4Address().getValue()).getAddress(),
+            actual.remote);
+        assertEquals(vxlanGpe.getVni().getValue().intValue(), actual.vni);
+        assertEquals(vxlanGpe.getNextProtocol().getIntValue(), actual.protocol);
+        assertEquals(vxlanGpe.getEncapVrfId().intValue(), actual.encapVrfId);
+        assertEquals(vxlanGpe.getDecapVrfId().intValue(), actual.decapVrfId);
+        return actual;
+    }
+
+    private void verifyVxlanGpeAddWasInvoked(final VxlanGpe vxlanGpe) throws VppBaseCallException {
+        final VxlanGpeAddDelTunnel actual = verifyVxlanGpeAddDelTunnelWasInvoked(vxlanGpe);
+        assertEquals(ADD_VXLAN_GPE, actual.isAdd);
+    }
+
+    private void verifyVxlanGpeDeleteWasInvoked(final VxlanGpe vxlanGpe) throws VppBaseCallException {
+        final VxlanGpeAddDelTunnel actual = verifyVxlanGpeAddDelTunnelWasInvoked(vxlanGpe);
+        assertEquals(DEL_VXLAN_GPE, actual.isAdd);
+    }
+
+    private static VxlanGpe generateVxlanGpe(long vni) {
+        final VxlanGpeBuilder builder = new VxlanGpeBuilder();
+        builder.setLocal(new IpAddress(new Ipv4Address("192.168.20.10")));
+        builder.setRemote(new IpAddress(new Ipv4Address("192.168.20.11")));
+        builder.setVni(new VxlanGpeVni(Long.valueOf(vni)));
+        builder.setNextProtocol(VxlanGpeNextProtocol.forValue(1));
+        builder.setEncapVrfId(Long.valueOf(123));
+        builder.setDecapVrfId(Long.valueOf(456));
+        return builder.build();
+    }
+
+    private static VxlanGpe generateVxlanGpe() {
+        return generateVxlanGpe(Long.valueOf(11));
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws Exception {
+        final VxlanGpe vxlanGpe = generateVxlanGpe();
+
+        whenVxlanGpeAddDelTunnelThenSuccess();
+        noMappingDefined(mappingContext, ifaceName, "test-instance");
+
+        customizer.writeCurrentAttributes(id, vxlanGpe, writeContext);
+        verifyVxlanGpeAddWasInvoked(vxlanGpe);
+        verify(mappingContext).put(eq(mappingIid(ifaceName, "test-instance")), eq(
+            mapping(ifaceName, 0).get()));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesMappingAlreadyPresent() throws Exception {
+        final VxlanGpe vxlanGpe = generateVxlanGpe();
+        final int ifaceId = 0;
+
+        whenVxlanGpeAddDelTunnelThenSuccess();
+        defineMapping(mappingContext, ifaceName, ifaceId, "test-instance");
+
+        customizer.writeCurrentAttributes(id, vxlanGpe, writeContext);
+        verifyVxlanGpeAddWasInvoked(vxlanGpe);
+
+        // Remove the first mapping before putting in the new one
+        verify(mappingContext).delete(eq(mappingIid(ifaceName, "test-instance")));
+        verify(mappingContext).put(eq(mappingIid(ifaceName, "test-instance")),
+            eq(mapping(ifaceName, ifaceId).get()));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesFailed() throws Exception {
+        final VxlanGpe vxlanGpe = generateVxlanGpe();
+
+        whenVxlanGpeAddDelTunnelThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(id, vxlanGpe, writeContext);
+        } catch (WriteFailedException.CreateFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyVxlanGpeAddWasInvoked(vxlanGpe);
+            // Mapping not stored due to failure
+            verify(mappingContext, times(0))
+                .put(eq(mappingIid(ifaceName, "test-instance")), eq(
+                    mapping(ifaceName, 0).get()));
+            return;
+        }
+        fail("WriteFailedException.CreateFailedException was expected");
+    }
+
+    @Test
+    public void testUpdateCurrentAttributes() throws Exception {
+        try {
+            customizer.updateCurrentAttributes(id, generateVxlanGpe(10), generateVxlanGpe(11), writeContext);
+        } catch (WriteFailedException.UpdateFailedException e) {
+            assertEquals(UnsupportedOperationException.class, e.getCause().getClass());
+            return;
+        }
+        fail("WriteFailedException.UpdateFailedException was expected");
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws Exception {
+        final VxlanGpe vxlanGpe = generateVxlanGpe();
+
+        whenVxlanGpeAddDelTunnelThenSuccess();
+        defineMapping(mappingContext, ifaceName, 1, "test-instance");
+
+        customizer.deleteCurrentAttributes(id, vxlanGpe, writeContext);
+        verifyVxlanGpeDeleteWasInvoked(vxlanGpe);
+        verify(mappingContext).delete(eq(mappingIid(ifaceName, "test-instance")));
+    }
+
+    @Test
+    public void testDeleteCurrentAttributesaFailed() throws Exception {
+        final VxlanGpe vxlanGpe = generateVxlanGpe();
+
+        whenVxlanGpeAddDelTunnelThenFailure();
+        defineMapping(mappingContext, ifaceName, 1, "test-instance");
+
+        try {
+            customizer.deleteCurrentAttributes(id, vxlanGpe, writeContext);
+        } catch (WriteFailedException.DeleteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verifyVxlanGpeDeleteWasInvoked(vxlanGpe);
+            verify(mappingContext, times(0)).delete(eq(mappingIid(ifaceName, "test-instance")));
+            return;
+        }
+        fail("WriteFailedException.DeleteFailedException was expected");
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/AclWriterTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/AclWriterTest.java
new file mode 100644
index 000000000..7641bd912
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/AclWriterTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessLists;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.EthAcl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessListsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.access.lists.AclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.IetfAclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ietf.acl.IngressBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class AclWriterTest extends WriterCustomizerTest {
+
+    private static final String ACL_NAME = "acl1";
+    private static final Class<? extends AclBase> ACL_TYPE = EthAcl.class;
+    private static final InstanceIdentifier<Acl> IID =
+        InstanceIdentifier.create(AccessLists.class).child(Acl.class, new AclKey(ACL_NAME, ACL_TYPE));
+
+    @Mock
+    private Acl acl;
+    private IetfAclWriter customizer;
+
+    @Override
+    public void setUp() {
+        customizer = new IetfAclWriter();
+        when(acl.getAclName()).thenReturn(ACL_NAME);
+        doReturn(ACL_TYPE).when(acl).getAclType();
+    }
+
+    private void defineInterfacesContext(final List<Interface> interfaces) {
+        when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.of(
+            new InterfacesBuilder().setInterface(interfaces).build()
+        ));
+    }
+
+    @Test
+    public void testWrite() throws Exception {
+        customizer.writeCurrentAttributes(IID, acl, writeContext);
+    }
+
+    @Test
+    public void testUpdate() throws WriteFailedException {
+        defineInterfacesContext(Collections.emptyList());
+        customizer.updateCurrentAttributes(IID, acl, acl, writeContext);
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        defineInterfacesContext(Collections.emptyList());
+        customizer.deleteCurrentAttributes(IID, acl, writeContext);
+    }
+
+    @Test(expected = WriteFailedException.class)
+    public void testDeleteFailed() throws WriteFailedException {
+        final Interface iface = new InterfaceBuilder().addAugmentation(VppInterfaceAugmentation.class,
+            new VppInterfaceAugmentationBuilder().setIetfAcl(
+                new IetfAclBuilder().setIngress(
+                    new IngressBuilder().setAccessLists(
+                        new AccessListsBuilder().setAcl(
+                            Collections.singletonList(new AclBuilder().setName(ACL_NAME).setType(ACL_TYPE).build())
+                        ).build()
+                    ).build()
+                ).build()
+            ).build()
+        ).build();
+        defineInterfacesContext(Collections.singletonList(iface));
+        customizer.deleteCurrentAttributes(IID, acl, writeContext);
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceEthWriterTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceEthWriterTest.java
new file mode 100644
index 000000000..ec1321670
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceEthWriterTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.common;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelSession;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceEth;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceEthBuilder;
+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.vpp.acl.rev161214.InterfaceMode;
+
+public class AceEthWriterTest {
+
+    private AceEthWriter writer;
+    private PacketHandling action;
+    private AceEth aceEth;
+
+    @Before
+    public void setUp() {
+        initMocks(this);
+        writer = new AceEthWriter();
+        action = new DenyBuilder().setDeny(true).build();
+        aceEth = new AceEthBuilder()
+            .setDestinationMacAddress(new MacAddress("11:22:33:44:55:66"))
+            .setDestinationMacAddressMask(new MacAddress("ff:ff:ff:ff:ff:ff"))
+            .setSourceMacAddress(new MacAddress("aa:bb:cc:dd:ee:ff"))
+            .setSourceMacAddressMask(new MacAddress("ff:ff:ff:00:00:00"))
+            .build();
+    }
+
+    @Test
+    public void testCreateTable() {
+        final int nextTableIndex = 42;
+        final ClassifyAddDelTable request = writer.createTable(aceEth, InterfaceMode.L2, nextTableIndex, 0);
+
+        assertEquals(1, request.isAdd);
+        assertEquals(-1, request.tableIndex);
+        assertEquals(1, request.nbuckets);
+        assertEquals(nextTableIndex, request.nextTableIndex);
+        assertEquals(0, request.skipNVectors);
+        assertEquals(AceEthWriter.MATCH_N_VECTORS, request.matchNVectors);
+        assertEquals(AceEthWriter.TABLE_MEM_SIZE, request.memorySize);
+
+        byte[] expectedMask = new byte[] {
+            // destination MAC:
+            (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+            // source MAC:
+            (byte) 0xff, (byte) 0xff, (byte) 0xff, 0, 0, 0,
+            0, 0, 0, 0
+        };
+        assertArrayEquals(expectedMask, request.mask);
+    }
+
+    @Test
+    public void testCreateClassifySession() {
+        final int tableIndex = 123;
+        final ClassifyAddDelSession request = writer.createSession(action, aceEth, InterfaceMode.L2, tableIndex, 0).get(0);
+
+        assertEquals(1, request.isAdd);
+        assertEquals(tableIndex, request.tableIndex);
+        assertEquals(0, request.hitNextIndex);
+
+        byte[] expectedMatch = new byte[] {
+            // destination MAC:
+            (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66,
+            // source MAC:
+            (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd, (byte) 0xee, (byte) 0xff,
+            0, 0, 0, 0
+        };
+        assertArrayEquals(expectedMatch, request.match);
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIp4WriterTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIp4WriterTest.java
new file mode 100644
index 000000000..cb3b246c6
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIp4WriterTest.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.common;
+
+import static io.fd.hc2vpp.v3po.interfaces.acl.common.AclTranslator.VLAN_TAG_LEN;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelSession;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.InterfaceMode;
+
+public class AceIp4WriterTest {
+
+    private AceIp4Writer writer;
+    private PacketHandling action;
+    private AceIp aceIp;
+
+    @Before
+    public void setUp() throws Exception {
+        initMocks(this);
+        writer = new AceIp4Writer();
+        action = new DenyBuilder().setDeny(true).build();
+        aceIp = new AceIpBuilder()
+            .setProtocol((short) 132)
+            .setDscp(new Dscp((short) 11))
+            .setAceIpVersion(new AceIpv4Builder()
+                .setSourceIpv4Network(new Ipv4Prefix("1.2.3.4/32"))
+                .setDestinationIpv4Network(new Ipv4Prefix("1.2.4.5/24"))
+                .build())
+            .setSourcePortRange(new SourcePortRangeBuilder().setLowerPort(new PortNumber(0x1111)).build())
+            .setDestinationPortRange(new DestinationPortRangeBuilder().setLowerPort(new PortNumber(0x2222)).build())
+            .build();
+    }
+
+    private static void verifyTableRequest(final ClassifyAddDelTable request, final int nextTableIndex,
+                                           final int vlanTags, final boolean isL2) {
+        assertEquals(1, request.isAdd);
+        assertEquals(-1, request.tableIndex);
+        assertEquals(1, request.nbuckets);
+        assertEquals(nextTableIndex, request.nextTableIndex);
+        assertEquals(0, request.skipNVectors);
+        assertEquals(AceIp4Writer.MATCH_N_VECTORS, request.matchNVectors);
+        assertEquals(AceIp4Writer.TABLE_MEM_SIZE, request.memorySize);
+
+        byte[] expectedMask = new byte[] {
+            // L2:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            // dscp:
+            (byte) 0x00, (byte) 0xfc,
+            // protocol:
+            0, 0, 0, 0, 0, 0, 0, (byte) 0xff, 0, 0,
+            // source address:
+            -1, -1, -1, -1,
+            // destination address:
+            -1, -1, -1, 0,
+            // source and destination port:
+            -1, -1, -1, -1,
+            // padding:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        };
+
+        if (isL2) {
+            expectedMask[12] = (byte) 0xff;
+            expectedMask[13] = (byte) 0xff;
+        }
+        AceIpWriterTestUtils
+            .assertArrayEqualsWithOffset(expectedMask, expectedMask.length, request.mask, vlanTags * VLAN_TAG_LEN);
+
+    }
+
+    private static void verifySessionRequest(final ClassifyAddDelSession request, final int tableIndex,
+                                             final int vlanTags, final boolean isL2) {
+        assertEquals(1, request.isAdd);
+        assertEquals(tableIndex, request.tableIndex);
+        assertEquals(0, request.hitNextIndex);
+
+        byte[] expectedMatch = new byte[] {
+            // L2:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            // dscp:
+            0, (byte) 0x2c,
+            // protocol (132):
+            0, 0, 0, 0, 0, 0, 0, (byte) 132, 0, 0,
+            // source address:
+            1, 2, 3, 4,
+            // destination address:
+            1, 2, 4, 0,
+            // source and destination port:
+            0x11, 0x11, 0x22, 0x22,
+            // padding:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        };
+
+        if (isL2) {
+            expectedMatch[12] = (byte) 0x08;
+            expectedMatch[13] = (byte) 0x00;
+        }
+        AceIpWriterTestUtils.assertArrayEqualsWithOffset(expectedMatch, expectedMatch.length, request.match, vlanTags * VLAN_TAG_LEN);
+
+    }
+
+    @Test
+    public void testCreateTable() throws Exception {
+        final int nextTableIndex = 42;
+        final ClassifyAddDelTable request = writer.createTable(aceIp, InterfaceMode.L3, nextTableIndex, 0);
+        verifyTableRequest(request, nextTableIndex, 0, false);
+    }
+
+    @Test
+    public void testCreateTableForL2Interface() throws Exception {
+        final int nextTableIndex = 42;
+        final ClassifyAddDelTable request = writer.createTable(aceIp, InterfaceMode.L2, nextTableIndex, 0);
+        verifyTableRequest(request, nextTableIndex, 0, true);
+    }
+
+    @Test
+    public void testCreateTable1VlanTag() throws Exception {
+        final int nextTableIndex = 42;
+        final int vlanTags = 1;
+        final ClassifyAddDelTable request = writer.createTable(aceIp, InterfaceMode.L3, nextTableIndex, vlanTags);
+        verifyTableRequest(request, nextTableIndex, vlanTags, false);
+    }
+
+    @Test
+    public void testCreateTable2VlanTags() throws Exception {
+        final int nextTableIndex = 42;
+        final int vlanTags = 2;
+        final ClassifyAddDelTable request = writer.createTable(aceIp, InterfaceMode.L3, nextTableIndex, vlanTags);
+        verifyTableRequest(request, nextTableIndex, vlanTags, false);
+    }
+
+    @Test
+    public void testCreateClassifySession() throws Exception {
+        final int tableIndex = 123;
+        final ClassifyAddDelSession request = writer.createSession(action, aceIp, InterfaceMode.L3, tableIndex, 0).get(0);
+        verifySessionRequest(request, tableIndex, 0, false);
+    }
+
+    @Test
+    public void testCreateClassifySessionForL2Interface() throws Exception {
+        final int tableIndex = 123;
+        final ClassifyAddDelSession request = writer.createSession(action, aceIp, InterfaceMode.L2, tableIndex, 0).get(0);
+        verifySessionRequest(request, tableIndex, 0, true);
+    }
+
+    @Test
+    public void testCreateClassifySession1VlanTag() throws Exception {
+        final int tableIndex = 123;
+        final int vlanTags = 1;
+        final ClassifyAddDelSession request = writer.createSession(action, aceIp, InterfaceMode.L3, tableIndex, vlanTags).get(0);
+        verifySessionRequest(request, tableIndex, vlanTags, false);
+    }
+
+    @Test
+    public void testCreateClassifySession2VlanTags() throws Exception {
+        final int tableIndex = 123;
+        final int vlanTags = 2;
+        final ClassifyAddDelSession request = writer.createSession(action, aceIp, InterfaceMode.L3, tableIndex, vlanTags).get(0);
+
+        verifySessionRequest(request, tableIndex, vlanTags, false);
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIp6WriterTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIp6WriterTest.java
new file mode 100644
index 000000000..30dff951b
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIp6WriterTest.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.common;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelSession;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6FlowLabel;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.InterfaceMode;
+
+public class AceIp6WriterTest {
+
+    private AceIp6Writer writer;
+    private PacketHandling action;
+    private AceIp aceIp;
+
+    @Before
+    public void setUp() {
+        initMocks(this);
+        writer = new AceIp6Writer();
+        action = new DenyBuilder().setDeny(true).build();
+        aceIp = new AceIpBuilder()
+            .setProtocol((short) 132)
+            .setDscp(new Dscp((short) 11))
+            .setAceIpVersion(new AceIpv6Builder()
+                .setFlowLabel(new Ipv6FlowLabel(123L))
+                .setSourceIpv6Network(new Ipv6Prefix("2001:db8:85a3:8d3:1319:8a2e:370:7348/128"))
+                .setDestinationIpv6Network(new Ipv6Prefix("fe80:1234:5678:abcd:ef01::/64"))
+                .build())
+            .setSourcePortRange(new SourcePortRangeBuilder().setLowerPort(new PortNumber(0x1111)).build())
+            .setDestinationPortRange(new DestinationPortRangeBuilder().setLowerPort(new PortNumber(0x2222)).build())
+            .build();
+    }
+
+
+    private static void verifyTableRequest(final ClassifyAddDelTable request, final int nextTableIndex,
+                                           final int vlanTags, final boolean isL2) {
+        assertEquals(1, request.isAdd);
+        assertEquals(-1, request.tableIndex);
+        assertEquals(1, request.nbuckets);
+        assertEquals(nextTableIndex, request.nextTableIndex);
+        assertEquals(0, request.skipNVectors);
+        assertEquals(vlanTags == 2 ? 5 : 4, request.matchNVectors);
+        assertEquals(AceIp6Writer.TABLE_MEM_SIZE, request.memorySize);
+
+        byte[] expectedMask = new byte[] {
+            // L2:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            // dscp, flow:
+            (byte) 0x0f, (byte) 0xcf, (byte) 0xff, (byte) 0xff,
+            // protocol:
+            0, 0, (byte) 0xff, 0,
+            // source address:
+            (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+            (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+            // destination address:
+            (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+            0, 0, 0, 0, 0, 0, 0, 0,
+            // source and destination port:
+            -1, -1, -1, -1,
+            // padding to multiple of 16B:
+            0, 0, 0, 0, 0, 0
+        };
+
+        if (isL2) {
+            expectedMask[12] = (byte) 0xff;
+            expectedMask[13] = (byte) 0xff;
+        }
+        AceIpWriterTestUtils.assertArrayEqualsWithOffset(expectedMask, vlanTags == 2 ? 80 : 64, request.mask, vlanTags * AclTranslator.VLAN_TAG_LEN);
+    }
+
+    private static void verifySessionRequest(final ClassifyAddDelSession request, final int tableIndex,
+                                             final int vlanTags, final boolean isL2) {
+        assertEquals(1, request.isAdd);
+        assertEquals(tableIndex, request.tableIndex);
+        assertEquals(0, request.hitNextIndex);
+
+        byte[] expectedMatch = new byte[] {
+            // L2:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            // dscp(11), flow(123):
+            (byte) 0x02, (byte) 0xc0, (byte) 0x00, (byte) 0x7b,
+            // protocol (132):
+            0, 0, (byte) 132, 0,
+            // source address:
+            (byte) 0x20, (byte) 0x01, (byte) 0x0d, (byte) 0xb8, (byte) 0x85, (byte) 0xa3, (byte) 0x08, (byte) 0xd3,
+            (byte) 0x13, (byte) 0x19, (byte) 0x8a, (byte) 0x2e, (byte) 0x03, (byte) 0x70, (byte) 0x73, (byte) 0x48,
+            // destination address:
+            (byte) 0xfe, (byte) 0x80, (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0xab, (byte) 0xcd,
+            0, 0, 0, 0, 0, 0, 0, 0,
+            // source and destination port:
+            0x11, 0x11, 0x22, 0x22,
+            // padding to multiple of 16B:
+            0, 0, 0, 0, 0, 0
+        };
+
+        if (isL2) {
+            expectedMatch[12] = (byte) 0x86;
+            expectedMatch[13] = (byte) 0xdd;
+        }
+        AceIpWriterTestUtils.assertArrayEqualsWithOffset(expectedMatch, vlanTags == 2 ? 80 : 64, request.match, vlanTags * AclTranslator.VLAN_TAG_LEN);
+
+    }
+
+    @Test
+    public void testCreateTable() {
+        final int nextTableIndex = 42;
+        final ClassifyAddDelTable request =
+            writer.createTable(aceIp, InterfaceMode.L3, nextTableIndex, 0);
+        verifyTableRequest(request, nextTableIndex, 0, false);
+    }
+
+    @Test
+    public void testCreateTableForL2Interface() {
+        final int nextTableIndex = 42;
+        final ClassifyAddDelTable request =
+            writer.createTable(aceIp, InterfaceMode.L2, nextTableIndex, 0);
+        verifyTableRequest(request, nextTableIndex, 0, true);
+    }
+
+    @Test
+    public void testCreateTable1VlanTag() {
+        final int nextTableIndex = 42;
+        final int vlanTags = 1;
+        final ClassifyAddDelTable request =
+            writer.createTable(aceIp, InterfaceMode.L3, nextTableIndex, vlanTags);
+        verifyTableRequest(request, nextTableIndex, vlanTags, false);
+    }
+
+    @Test
+    public void testCreateTable2VlanTags() {
+        final int nextTableIndex = 42;
+        final int vlanTags = 2;
+        final ClassifyAddDelTable request =
+            writer.createTable(aceIp, InterfaceMode.L3, nextTableIndex, vlanTags);
+        verifyTableRequest(request, nextTableIndex, vlanTags, false);
+    }
+
+    @Test
+    public void testCreateClassifySession() {
+        final int tableIndex = 123;
+        final ClassifyAddDelSession request =
+            writer.createSession(action, aceIp, InterfaceMode.L3, tableIndex, 0).get(0);
+        verifySessionRequest(request, tableIndex, 0, false);
+    }
+
+    @Test
+    public void testCreateClassifySessionForL2Interface() {
+        final int tableIndex = 123;
+        final ClassifyAddDelSession request =
+            writer.createSession(action, aceIp, InterfaceMode.L2, tableIndex, 0).get(0);
+        verifySessionRequest(request, tableIndex, 0, true);
+    }
+
+    @Test
+    public void testCreateClassifySession1VlanTag() {
+        final int tableIndex = 123;
+        final int vlanTags = 1;
+        final ClassifyAddDelSession request =
+            writer.createSession(action, aceIp, InterfaceMode.L3, tableIndex, vlanTags).get(0);
+        verifySessionRequest(request, tableIndex, vlanTags, false);
+    }
+
+    @Test
+    public void testCreateClassifySession2VlanTags() {
+        final int tableIndex = 123;
+        final int vlanTags = 2;
+        final ClassifyAddDelSession request =
+            writer.createSession(action, aceIp, InterfaceMode.L3, tableIndex, vlanTags).get(0);
+        verifySessionRequest(request, tableIndex, vlanTags, false);
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIpAndEthWriterTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIpAndEthWriterTest.java
new file mode 100644
index 000000000..34c7334b8
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIpAndEthWriterTest.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.common;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelSession;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRangeBuilder;
+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.vpp.acl.rev161214.InterfaceMode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpAndEth;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpAndEthBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.and.eth.ace.ip.version.AceIpv4Builder;
+
+public class AceIpAndEthWriterTest {
+
+    private AceIpAndEthWriter writer;
+    private PacketHandling action;
+    private AceIpAndEth ace;
+
+    @Before
+    public void setUp() {
+        initMocks(this);
+        writer = new AceIpAndEthWriter();
+        action = new DenyBuilder().setDeny(true).build();
+        ace = new AceIpAndEthBuilder()
+            .setDestinationMacAddress(new MacAddress("11:22:33:44:55:66"))
+            .setSourceMacAddress(new MacAddress("aa:bb:cc:dd:ee:ff"))
+            .setAceIpVersion(new AceIpv4Builder()
+                .setSourceIpv4Network(new Ipv4Prefix("1.2.3.4/32")).build())
+            .setSourcePortRange(new SourcePortRangeBuilder().setLowerPort(new PortNumber(0x1111)).build())
+            .setDestinationPortRange(new DestinationPortRangeBuilder().setLowerPort(new PortNumber(0x2222)).build())
+            .build();
+    }
+
+    @Test
+    public void testCreateTable() {
+        final int nextTableIndex = 42;
+        final ClassifyAddDelTable request = writer.createTable(ace, InterfaceMode.L2, nextTableIndex, 0);
+
+        assertEquals(1, request.isAdd);
+        assertEquals(-1, request.tableIndex);
+        assertEquals(1, request.nbuckets);
+        assertEquals(nextTableIndex, request.nextTableIndex);
+        assertEquals(0, request.skipNVectors);
+        assertEquals(3, request.matchNVectors);
+        assertEquals(AceEthWriter.TABLE_MEM_SIZE, request.memorySize);
+
+        byte[] expectedMask = new byte[] {
+            // destination MAC:
+            -1, -1, -1, -1, -1, -1,
+            // source MAC:
+            -1, -1, -1, -1, -1, -1,
+            // ether type:
+            -1, -1,
+            // IP header
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            // source address:
+            -1, -1, -1, -1,
+            // destination address:
+            0, 0, 0, 0,
+            // source and destination port:
+            -1, -1, -1, -1,
+            // padding:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        };
+        assertArrayEquals(expectedMask, request.mask);
+    }
+
+    @Test
+    public void testCreateClassifySession() {
+        final int tableIndex = 123;
+        final ClassifyAddDelSession request = writer.createSession(action, ace, InterfaceMode.L2, tableIndex, 0).get(0);
+
+        assertEquals(1, request.isAdd);
+        assertEquals(tableIndex, request.tableIndex);
+        assertEquals(0, request.hitNextIndex);
+
+        byte[] expectedMatch = new byte[] {
+            // destination MAC:
+            (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66,
+            // source MAC:
+            (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd, (byte) 0xee, (byte) 0xff,
+            // ether type (IP4):
+            0x08, 0,
+            // IP header
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            // source address:
+            1, 2, 3, 4,
+            // destination address:
+            0, 0, 0, 0,
+            // source and destination port:
+            0x11, 0x11, 0x22, 0x22,
+            // padding:
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        };
+        assertArrayEquals(expectedMatch, request.match);
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIpWriterTestUtils.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIpWriterTestUtils.java
new file mode 100644
index 000000000..087d91d26
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AceIpWriterTestUtils.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.common;
+
+import static org.junit.Assert.assertArrayEquals;
+
+final class AceIpWriterTestUtils {
+
+    private AceIpWriterTestUtils() {
+        throw new UnsupportedOperationException("This utility class cannot be instantiated");
+    }
+
+    protected static void assertArrayEqualsWithOffset(final byte[] baseExpected, final int expectedLength, final byte[] actual,
+                                                      final int offset) {
+        byte[] expected = new byte[expectedLength];
+        System.arraycopy(baseExpected, 0, expected, offset, Math.min(baseExpected.length, expectedLength-offset));
+
+        assertArrayEquals(expected, actual);
+    }
+}
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AclTableContextManagerImplTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AclTableContextManagerImplTest.java
new file mode 100644
index 000000000..3f106ccce
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/AclTableContextManagerImplTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.common;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import io.fd.honeycomb.translate.MappingContext;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev161214.mapping.entry.context.attributes.acl.mapping.entry.context.MappingTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev161214.mapping.entry.context.attributes.acl.mapping.entry.context.mapping.table.MappingEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev161214.mapping.entry.context.attributes.acl.mapping.entry.context.mapping.table.MappingEntryBuilder;
+
+public class AclTableContextManagerImplTest {
+
+    private AclTableContextManagerImpl ctx;
+    @Mock
+    private MappingContext mappingContext;
+    private static final int INDEX = 42;
+
+    @Before
+    public void setUp() throws Exception {
+        initMocks(this);
+        ctx = new AclTableContextManagerImpl(MappingTable.Direction.Ingress);
+    }
+
+    @Test
+    public void testAddEntry() throws Exception {
+        final MappingEntry entry =
+            new MappingEntryBuilder().setL2TableId(1).setIp4TableId(2).setIp6TableId(3).setIndex(INDEX).build();
+        ctx.addEntry(entry, mappingContext);
+        verify(mappingContext).put(ctx.getId(INDEX), entry);
+    }
+
+    @Test
+    public void testRemoveEntry() throws Exception {
+        ctx.removeEntry(INDEX, mappingContext);
+        verify(mappingContext).delete(ctx.getId(INDEX));
+    }
+
+    @Test
+    public void testReadEntry() throws Exception {
+        ctx.getEntry(INDEX, mappingContext);
+        verify(mappingContext).read(ctx.getId(INDEX));
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/PortPairTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/PortPairTest.java
new file mode 100644
index 000000000..f5c319fb6
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/common/PortPairTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.common;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.hasSize;
+
+import java.util.List;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRange;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRange;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRangeBuilder;
+
+public class PortPairTest {
+
+    @Test
+    public void testSingleSrc() {
+        final SourcePortRange src = new SourcePortRangeBuilder().setLowerPort(new PortNumber(123)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(src, null);
+        assertThat(portPairs, hasSize(1));
+        assertThat(portPairs, contains(new PortPair(123, null)));
+    }
+
+    @Test
+    public void testSrcRange() {
+        final SourcePortRange src = new SourcePortRangeBuilder()
+            .setLowerPort(new PortNumber(123))
+            .setUpperPort(new PortNumber(125)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(src, null);
+        assertThat(portPairs, hasSize(3));
+        assertThat(portPairs, contains(new PortPair(123, null), new PortPair(124, null), new PortPair(125, null)));
+    }
+
+    @Test
+    public void testSrcRangeWithDst() {
+        final SourcePortRange src = new SourcePortRangeBuilder()
+            .setLowerPort(new PortNumber(123))
+            .setUpperPort(new PortNumber(125)).build();
+        final DestinationPortRange dst = new DestinationPortRangeBuilder().setLowerPort(new PortNumber(111)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(src, dst);
+        assertThat(portPairs, hasSize(3));
+        assertThat(portPairs, contains(new PortPair(123, 111), new PortPair(124, 111), new PortPair(125, 111)));
+    }
+
+    @Test
+    public void testSingleDst() {
+        final DestinationPortRange dst = new DestinationPortRangeBuilder().setLowerPort(new PortNumber(123)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(null, dst);
+        assertThat(portPairs, hasSize(1));
+        assertThat(portPairs, contains(new PortPair(null, 123)));
+    }
+
+    @Test
+    public void testDstRange() {
+        final DestinationPortRange dst = new DestinationPortRangeBuilder()
+            .setLowerPort(new PortNumber(10))
+            .setUpperPort(new PortNumber(11)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(null, dst);
+        assertThat(portPairs, hasSize(2));
+        assertThat(portPairs, contains(new PortPair(null, 10), new PortPair(null, 11)));
+    }
+
+    @Test
+    public void testDstRangeWithSrc() {
+        final SourcePortRange src = new SourcePortRangeBuilder().setLowerPort(new PortNumber(111)).build();
+        final DestinationPortRange dst = new DestinationPortRangeBuilder()
+            .setLowerPort(new PortNumber(10))
+            .setUpperPort(new PortNumber(11)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(src, dst);
+        assertThat(portPairs, hasSize(2));
+        assertThat(portPairs, contains(new PortPair(111, 10), new PortPair(111, 11)));
+    }
+
+    @Test
+    public void testSinglePair() {
+        final SourcePortRange src = new SourcePortRangeBuilder().setLowerPort(new PortNumber(123)).build();
+        final DestinationPortRange dst = new DestinationPortRangeBuilder().setLowerPort(new PortNumber(321)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(src, dst);
+        assertThat(portPairs, hasSize(1));
+        assertThat(portPairs, contains(new PortPair(123, 321)));
+    }
+
+    @Test
+    public void testCartesianProduct() {
+        final SourcePortRange src = new SourcePortRangeBuilder()
+            .setLowerPort(new PortNumber(1))
+            .setUpperPort(new PortNumber(2)).build();
+        final DestinationPortRange dst = new DestinationPortRangeBuilder()
+            .setLowerPort(new PortNumber(1))
+            .setUpperPort(new PortNumber(3)).build();
+        final List<PortPair> portPairs = PortPair.fromRange(src, dst);
+        assertThat(portPairs, hasSize(6));
+        assertThat(portPairs,
+            contains(new PortPair(1, 1), new PortPair(1, 2), new PortPair(1, 3), new PortPair(2, 1), new PortPair(2, 2),
+                new PortPair(2, 3)));
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/EgressIetfAclWriterTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/EgressIetfAclWriterTest.java
new file mode 100644
index 000000000..0b75b5bce
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/EgressIetfAclWriterTest.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.egress;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.v3po.interfaces.acl.common.AclTableContextManager;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelSessionReply;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTableReply;
+import io.fd.vpp.jvpp.core.dto.ClassifySetInterfaceL2Tables;
+import io.fd.vpp.jvpp.core.dto.ClassifySetInterfaceL2TablesReply;
+import java.util.Collections;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.EthAcl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.AccessListEntriesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.ActionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.MatchesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.PermitBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv4Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ietf.acl.Egress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ietf.acl.EgressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev161214.mapping.entry.context.attributes.acl.mapping.entry.context.mapping.table.MappingEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.InterfaceMode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessLists;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessListsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.access.lists.AclBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class EgressIetfAclWriterTest extends WriterCustomizerTest {
+
+    private static final int IF_INDEX = 1;
+    private static final String ACL_NAME = "acl1";
+    private static final Class<? extends AclBase> ACL_TYPE = EthAcl.class;
+
+    private EgressIetfAclWriter writer;
+    @Mock
+    private AclTableContextManager aclCtx;
+    @Mock
+    private InstanceIdentifier<?> id;
+
+    @Override
+    protected void setUp() throws Exception {
+        writer = new EgressIetfAclWriter(api, aclCtx);
+    }
+
+    private static ClassifyAddDelTable classifyAddDelTable(final int tableIndex) {
+        final ClassifyAddDelTable reply = new ClassifyAddDelTable();
+        reply.tableIndex = tableIndex;
+        return reply;
+    }
+
+    private ClassifySetInterfaceL2Tables classifySetInterfaceL2TablesRequest() {
+        final ClassifySetInterfaceL2Tables request = new ClassifySetInterfaceL2Tables();
+        request.isInput = 0;
+        request.ip4TableIndex = -1;
+        request.ip6TableIndex = -1;
+        request.otherTableIndex = -1;
+        request.swIfIndex = IF_INDEX;
+        return request;
+    }
+
+    @Test
+    public void testDeleteAcl() throws Exception {
+        when(api.classifyAddDelTable(any())).thenReturn(future(new ClassifyAddDelTableReply()));
+        when(api.classifySetInterfaceL2Tables(any())).thenReturn(future(new ClassifySetInterfaceL2TablesReply()));
+        when(aclCtx.getEntry(IF_INDEX, mappingContext)).thenReturn(Optional.of(
+            new MappingEntryBuilder()
+                .setIndex(IF_INDEX)
+                .setL2TableId(1)
+                .setIp4TableId(2)
+                .setIp6TableId(3)
+                .build()));
+
+        writer.deleteAcl(id, IF_INDEX, mappingContext);
+
+        verify(api).classifySetInterfaceL2Tables(classifySetInterfaceL2TablesRequest());
+        verify(api).classifyAddDelTable(classifyAddDelTable(1));
+        verify(api).classifyAddDelTable(classifyAddDelTable(2));
+        verify(api).classifyAddDelTable(classifyAddDelTable(3));
+        verify(aclCtx).removeEntry(IF_INDEX, mappingContext);
+    }
+
+    @Test
+    public void testWrite() throws Exception {
+        when(api.classifyAddDelTable(any())).thenReturn(future(new ClassifyAddDelTableReply()));
+        when(api.classifyAddDelSession(any())).thenReturn(future(new ClassifyAddDelSessionReply()));
+        when(api.classifySetInterfaceL2Tables(any())).thenReturn(future(new ClassifySetInterfaceL2TablesReply()));
+
+        final Egress
+            acl = new EgressBuilder().setAccessLists(
+            new AccessListsBuilder().setAcl(
+                Collections.singletonList(new AclBuilder()
+                    .setName(ACL_NAME)
+                    .setType(ACL_TYPE)
+                    .build())
+            ).setMode(InterfaceMode.L2).build()
+        ).build();
+
+        final AccessLists accessLists = acl.getAccessLists();
+
+        when(writeContext.readAfter(any())).thenReturn(Optional.of(
+            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclBuilder()
+                .setAccessListEntries(
+                    new AccessListEntriesBuilder().setAce(Collections.singletonList(new AceBuilder()
+                        .setMatches(new MatchesBuilder().setAceType(
+                            new AceIpBuilder()
+                                .setAceIpVersion(new AceIpv4Builder().build())
+                                .setProtocol((short) 1)
+                                .build()
+                        ).build())
+                        .setActions(new ActionsBuilder().setPacketHandling(new PermitBuilder().build()).build())
+                        .build())).build()
+                ).build()
+
+        ));
+
+        writer.write(id, IF_INDEX, accessLists.getAcl(), accessLists.getDefaultAction(), accessLists.getMode(),
+            writeContext, mappingContext);
+
+        final ClassifySetInterfaceL2Tables request = new ClassifySetInterfaceL2Tables();
+        request.isInput = 0;
+        request.swIfIndex = IF_INDEX;
+        request.otherTableIndex = -1;
+        request.ip4TableIndex = 0;
+        request.ip6TableIndex = -1;
+        verify(api).classifySetInterfaceL2Tables(request);
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/IetfAclCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/IetfAclCustomizerTest.java
new file mode 100644
index 000000000..07e6518e5
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/IetfAclCustomizerTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.egress;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+import io.fd.hc2vpp.v3po.interfaces.acl.common.IetfAclWriter;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import java.util.Collections;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.IetfAcl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ietf.acl.Egress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ietf.acl.EgressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.InterfaceMode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.MixedAcl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessLists;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessListsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.access.lists.AclBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class IetfAclCustomizerTest extends WriterCustomizerTest {
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String IF_NAME = "local0";
+    private static final int IF_INDEX = 1;
+    private static final InstanceIdentifier<Egress> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)).augmentation(
+            VppInterfaceAugmentation.class).child(IetfAcl.class).child(Egress.class);
+    private static final String ACL_NAME = "acl1";
+    private static final Class<? extends AclBase> ACL_TYPE = MixedAcl.class;
+
+    @Mock
+    private IetfAclWriter aclWriter;
+    private IetfAclCustomizer customizer;
+
+    @Override
+    protected void setUp() {
+        customizer = new IetfAclCustomizer(aclWriter, new NamingContext("prefix", IFC_TEST_INSTANCE));
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+    }
+
+    private static Egress acl(final InterfaceMode mode) {
+        return new EgressBuilder().setAccessLists(
+            new AccessListsBuilder().setAcl(
+                Collections.singletonList(new AclBuilder()
+                    .setName(ACL_NAME)
+                    .setType(ACL_TYPE)
+                    .build())
+            ).setMode(mode)
+                .build()
+        ).build();
+    }
+
+    private void verifyWrite(final AccessLists accessLists) throws WriteFailedException {
+        verify(aclWriter)
+            .write(IID, IF_INDEX, accessLists.getAcl(), accessLists.getDefaultAction(), accessLists.getMode(),
+                writeContext, mappingContext);
+    }
+
+    private void verifyDelete() throws WriteFailedException {
+        verify(aclWriter).deleteAcl(IID, IF_INDEX, mappingContext);
+    }
+
+    @Test
+    public void testWriteL3() throws Exception {
+        customizer.writeCurrentAttributes(IID, acl(InterfaceMode.L3), writeContext);
+        verifyZeroInteractions(aclWriter);
+    }
+
+    @Test
+    public void testWriteL2() throws Exception {
+        final Egress acl = acl(InterfaceMode.L2);
+        customizer.writeCurrentAttributes(IID, acl, writeContext);
+        verifyWrite(acl.getAccessLists());
+    }
+
+    @Test
+    public void testUpdate() throws Exception {
+        final Egress aclBefore = acl(InterfaceMode.L3);
+        final Egress aclAfter = acl(InterfaceMode.L2);
+        customizer.updateCurrentAttributes(IID, aclBefore, aclAfter, writeContext);
+        verifyDelete();
+        verifyWrite(aclAfter.getAccessLists());
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        final Egress acl = acl(InterfaceMode.L2);
+        customizer.deleteCurrentAttributes(IID, acl, writeContext);
+        verifyDelete();
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/SubInterfaceIetfAclCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/SubInterfaceIetfAclCustomizerTest.java
new file mode 100644
index 000000000..24c57a1d5
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/egress/SubInterfaceIetfAclCustomizerTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.egress;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.v3po.interfaces.acl.common.IetfAclWriter;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import java.util.Collections;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.InterfaceMode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.MixedAcl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessLists;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessListsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.access.lists.AclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.SubinterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.IetfAcl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.ietf.acl.Egress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.ietf.acl.EgressBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class SubInterfaceIetfAclCustomizerTest extends WriterCustomizerTest {
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String IF_NAME = "local0";
+    private static final int IF_INDEX = 1;
+    private static final String SUBIF_NAME = "local0.0";
+    private static final int SUBIF_INDEX = 11;
+    private static final long SUBIF_ID = 0;
+    private static final InstanceIdentifier<Egress> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)).augmentation(
+            SubinterfaceAugmentation.class).child(SubInterfaces.class)
+            .child(SubInterface.class, new SubInterfaceKey(SUBIF_ID)).child(IetfAcl.class).child(Egress.class);
+    private static final String ACL_NAME = "acl1";
+    private static final Class<? extends AclBase> ACL_TYPE = MixedAcl.class;
+
+    @Mock
+    private IetfAclWriter aclWriter;
+    private SubInterfaceIetfAclCustomizer customizer;
+
+    @Override
+    protected void setUp() {
+        customizer = new SubInterfaceIetfAclCustomizer(aclWriter, new NamingContext("prefix", IFC_TEST_INSTANCE));
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+        defineMapping(mappingContext, SUBIF_NAME, SUBIF_INDEX, IFC_TEST_INSTANCE);
+
+
+        when(writeContext.readAfter(IID.firstIdentifierOf(SubInterface.class))).thenReturn(Optional.of(
+            new SubInterfaceBuilder().build()
+        ));
+    }
+
+    private static Egress acl(final InterfaceMode mode) {
+        return new EgressBuilder().setAccessLists(
+            new AccessListsBuilder().setAcl(
+                Collections.singletonList(new AclBuilder()
+                    .setName(ACL_NAME)
+                    .setType(ACL_TYPE)
+                    .build())
+            ).setMode(mode)
+                .build()
+        ).build();
+    }
+
+    private void verifyWrite(final AccessLists accessLists) throws WriteFailedException {
+        verify(aclWriter)
+            .write(IID, SUBIF_INDEX, accessLists.getAcl(), accessLists.getDefaultAction(), accessLists.getMode(),
+                writeContext, 0, mappingContext);
+    }
+
+    private void verifyDelete() throws WriteFailedException {
+        verify(aclWriter).deleteAcl(IID, SUBIF_INDEX, mappingContext);
+    }
+
+    @Test
+    public void testWriteL3() throws Exception {
+        customizer.writeCurrentAttributes(IID, acl(InterfaceMode.L3), writeContext);
+        verifyZeroInteractions(aclWriter);
+    }
+
+    @Test
+    public void testWriteL2() throws Exception {
+        final Egress acl = acl(InterfaceMode.L2);
+        customizer.writeCurrentAttributes(IID, acl, writeContext);
+        verifyWrite(acl.getAccessLists());
+    }
+
+    @Test
+    public void testUpdate() throws Exception {
+        final Egress aclBefore = acl(InterfaceMode.L3);
+        final Egress aclAfter = acl(InterfaceMode.L2);
+        customizer.updateCurrentAttributes(IID, aclBefore, aclAfter, writeContext);
+        verifyDelete();
+        verifyWrite(aclAfter.getAccessLists());
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        final Egress acl = acl(InterfaceMode.L2);
+        customizer.deleteCurrentAttributes(IID, acl, writeContext);
+        verifyDelete();
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/IetfAclCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/IetfAclCustomizerTest.java
new file mode 100644
index 000000000..9b7267d52
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/IetfAclCustomizerTest.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.ingress;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.v3po.interfaces.acl.common.AclTableContextManager;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelSession;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelSessionReply;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTable;
+import io.fd.vpp.jvpp.core.dto.ClassifyAddDelTableReply;
+import io.fd.vpp.jvpp.core.dto.ClassifyTableByInterface;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterface;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterfaceReply;
+import java.util.Arrays;
+import java.util.Collections;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.EthAcl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.AccessListEntriesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.ActionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.MatchesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Deny;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Permit;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.PermitBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.IetfAcl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ietf.acl.Ingress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ietf.acl.IngressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev161214.mapping.entry.context.attributes.acl.mapping.entry.context.mapping.table.MappingEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessListsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.access.lists.AclBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class IetfAclCustomizerTest extends WriterCustomizerTest {
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String IF_NAME = "local0";
+    private static final int IF_INDEX = 1;
+    private static final InstanceIdentifier<Ingress> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)).augmentation(
+            VppInterfaceAugmentation.class).child(IetfAcl.class).child(Ingress.class);
+    private static final String ACL_NAME = "acl1";
+    private static final Class<? extends AclBase> ACL_TYPE = EthAcl.class;
+
+    @Mock
+    private AclTableContextManager aclCtx;
+
+    private IetfAclCustomizer customizer;
+    private Ingress acl;
+    private int DENY = 0;
+    private int PERMIT = -1;
+
+    @Override
+    protected void setUp() {
+        customizer = new IetfAclCustomizer(new IngressIetfAclWriter(api, aclCtx), new NamingContext("prefix", IFC_TEST_INSTANCE));
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+        acl = new IngressBuilder().setAccessLists(
+            new AccessListsBuilder().setAcl(
+                Collections.singletonList(new AclBuilder()
+                    .setName(ACL_NAME)
+                    .setType(ACL_TYPE)
+                    .build())
+            ).build()
+        ).build();
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        when(api.classifyAddDelTable(any())).thenReturn(future(new ClassifyAddDelTableReply()));
+        when(api.classifyAddDelSession(any())).thenReturn(future(new ClassifyAddDelSessionReply()));
+
+        when(writeContext.readAfter(any())).thenReturn(Optional.of(
+            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclBuilder()
+                .setAccessListEntries(
+                    new AccessListEntriesBuilder().setAce(Arrays.asList(ace(permit()), ace(permit()), ace(deny())
+                    )).build()
+                ).build()
+
+        ));
+        when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply()));
+
+        customizer.writeCurrentAttributes(IID, acl, writeContext);
+
+        final InOrder inOrder = Mockito.inOrder(api);
+        inOrder.verify(api).classifyAddDelTable(argThat(actionOnMissEquals(DENY))); // default action
+        inOrder.verify(api).classifyAddDelTable(any());
+        inOrder.verify(api).classifyAddDelSession(argThat(actionOnHitEquals(DENY))); // last deny ACE
+        inOrder.verify(api).classifyAddDelTable(any());
+        inOrder.verify(api).classifyAddDelSession(argThat(actionOnHitEquals(PERMIT)));
+        inOrder.verify(api).classifyAddDelTable(any());
+        inOrder.verify(api).classifyAddDelSession(argThat(actionOnHitEquals(PERMIT)));
+        inOrder.verify(api).inputAclSetInterface(inputAclSetInterfaceWriteRequest()); // assignment
+    }
+
+    private ArgumentMatcher<ClassifyAddDelTable> actionOnMissEquals(final int action) {
+        return table -> table.missNextIndex == action;
+    }
+
+
+    private ArgumentMatcher<ClassifyAddDelSession> actionOnHitEquals(final int action) {
+        return session -> session.hitNextIndex == action;
+    }
+
+    private Deny deny() {
+        return new DenyBuilder().build();
+    }
+
+    private Permit permit() {
+        return new PermitBuilder().build();
+    }
+
+    private static Ace ace(final PacketHandling action) {
+        return new AceBuilder()
+            .setMatches(new MatchesBuilder().setAceType(
+                new AceIpBuilder()
+                    .setAceIpVersion(new AceIpv6Builder().build())
+                    .setProtocol((short) 1)
+                    .build()
+            ).build())
+            .setActions(new ActionsBuilder().setPacketHandling(action).build())
+            .build();
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply()));
+        when(api.classifyAddDelTable(any())).thenReturn(future(new ClassifyAddDelTableReply()));
+        when(aclCtx.getEntry(IF_INDEX, mappingContext)).thenReturn(Optional.of(
+            new MappingEntryBuilder()
+                .setIndex(IF_INDEX)
+                .setL2TableId(1)
+                .setIp4TableId(2)
+                .setIp6TableId(3)
+                .build()));
+
+        customizer.deleteCurrentAttributes(IID, acl, writeContext);
+
+        final ClassifyTableByInterface expectedRequest = new ClassifyTableByInterface();
+        expectedRequest.swIfIndex = IF_INDEX;
+        verify(api).inputAclSetInterface(inputAclSetInterfaceDeleteRequest());
+        verify(api).classifyAddDelTable(classifyAddDelTable(1));
+        verify(api).classifyAddDelTable(classifyAddDelTable(2));
+        verify(api).classifyAddDelTable(classifyAddDelTable(3));
+    }
+
+    private static InputAclSetInterface inputAclSetInterfaceDeleteRequest() {
+        final InputAclSetInterface request = new InputAclSetInterface();
+        request.swIfIndex = IF_INDEX;
+        request.l2TableIndex = 1;
+        request.ip4TableIndex = 2;
+        request.ip6TableIndex = 3;
+        return request;
+    }
+
+    private static ClassifyAddDelTable classifyAddDelTable(final int tableIndex) {
+        final ClassifyAddDelTable reply = new ClassifyAddDelTable();
+        reply.tableIndex = tableIndex;
+        return reply;
+    }
+
+    private static InputAclSetInterface inputAclSetInterfaceWriteRequest() {
+        final InputAclSetInterface request = new InputAclSetInterface();
+        request.swIfIndex = IF_INDEX;
+        request.isAdd = 1;
+        request.l2TableIndex = -1;
+        request.ip4TableIndex = -1;
+        request.ip6TableIndex = 0;
+        return request;
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/SubInterfaceAclCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/SubInterfaceAclCustomizerTest.java
new file mode 100644
index 000000000..8b088883f
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/SubInterfaceAclCustomizerTest.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.ingress;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.v3po.vppclassifier.VppClassifierContextManager;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterface;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterfaceReply;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.acl.base.attributes.Ip4Acl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.acl.base.attributes.Ip4AclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.acl.base.attributes.Ip6Acl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.acl.base.attributes.Ip6AclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.SubinterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.Acl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.acl.Ingress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.acl.IngressBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class SubInterfaceAclCustomizerTest extends WriterCustomizerTest {
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String IF_NAME = "local0";
+    private static final int IF_INDEX = 1;
+    private static final String SUBIF_NAME = "local0.0";
+    private static final int SUBIF_INDEX = 11;
+    private static final long SUBIF_ID = 0;
+    private static final String TABLE_NAME = "table0";
+    private static final int TABLE_INDEX = 123;
+
+    private static final InstanceIdentifier<Ingress> IID =
+            InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)).augmentation(
+                    SubinterfaceAugmentation.class).child(SubInterfaces.class)
+                    .child(SubInterface.class, new SubInterfaceKey(SUBIF_ID)).child(Acl.class).child(Ingress.class);
+
+    @Mock
+    private VppClassifierContextManager classifyTableContext;
+
+    private SubInterfaceAclCustomizer customizer;
+
+    @Override
+    protected void setUp() throws Exception {
+        customizer = new SubInterfaceAclCustomizer(api, new NamingContext("prefix", IFC_TEST_INSTANCE),
+                classifyTableContext);
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+        defineMapping(mappingContext, SUBIF_NAME, SUBIF_INDEX, IFC_TEST_INSTANCE);
+        when(classifyTableContext.getTableIndex(TABLE_NAME, mappingContext)).thenReturn(TABLE_INDEX);
+    }
+
+    @Test
+    public void testCreate() throws WriteFailedException {
+        when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply()));
+        customizer.writeCurrentAttributes(IID, ip4Acl(), writeContext);
+        verify(api).inputAclSetInterface(expectedIp4AclRequest());
+    }
+
+    @Test(expected = WriteFailedException.class)
+    public void testCreateFailed() throws WriteFailedException {
+        when(api.inputAclSetInterface(any())).thenReturn(failedFuture());
+        customizer.writeCurrentAttributes(IID, ip4Acl(), writeContext);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdate() throws WriteFailedException {
+        customizer.updateCurrentAttributes(IID, ip4Acl(), ip6Acl(), writeContext);
+    }
+
+    @Test
+    public void testDelete() throws Exception {
+        when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply()));
+        customizer.deleteCurrentAttributes(IID, ip6Acl(), writeContext);
+        verify(api).inputAclSetInterface(expectedIp6AclRequest());
+    }
+
+    @Test(expected = WriteFailedException.class)
+    public void testDeleteFailed() throws WriteFailedException {
+        when(api.inputAclSetInterface(any())).thenReturn(failedFuture());
+        customizer.deleteCurrentAttributes(IID, ip4Acl(), writeContext);
+    }
+
+    private Ingress ip4Acl() {
+        final IngressBuilder builder = new IngressBuilder();
+        final Ip4Acl acl = new Ip4AclBuilder().setClassifyTable(TABLE_NAME).build();
+        builder.setIp4Acl(acl);
+        return builder.build();
+    }
+
+    private InputAclSetInterface expectedIp4AclRequest() {
+        final InputAclSetInterface request = new InputAclSetInterface();
+        request.isAdd = 1;
+        request.l2TableIndex = -1;
+        request.ip4TableIndex = TABLE_INDEX;
+        request.ip6TableIndex = -1;
+        request.swIfIndex = SUBIF_INDEX;
+        return request;
+    }
+
+    private Ingress ip6Acl() {
+        final IngressBuilder builder = new IngressBuilder();
+        final Ip6Acl acl = new Ip6AclBuilder().setClassifyTable(TABLE_NAME).build();
+        builder.setIp6Acl(acl);
+        return builder.build();
+    }
+
+    private InputAclSetInterface expectedIp6AclRequest() {
+        final InputAclSetInterface request = new InputAclSetInterface();
+        request.isAdd = 0;
+        request.l2TableIndex = -1;
+        request.ip4TableIndex = -1;
+        request.ip6TableIndex = TABLE_INDEX;
+        request.swIfIndex = SUBIF_INDEX;
+        return request;
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/SubInterfaceIetfAclCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/SubInterfaceIetfAclCustomizerTest.java
new file mode 100644
index 000000000..e3c1d86f9
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/acl/ingress/SubInterfaceIetfAclCustomizerTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.acl.ingress;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.v3po.interfaces.acl.IetfAclWriter;
+import io.fd.hc2vpp.v3po.interfaces.acl.common.AclTableContextManager;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.core.dto.ClassifyTableByInterface;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterface;
+import io.fd.vpp.jvpp.core.dto.InputAclSetInterfaceReply;
+import java.util.Collections;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.EthAcl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.AccessListEntriesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev161214.mapping.entry.context.attributes.acl.mapping.entry.context.mapping.table.MappingEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.AccessListsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.ietf.acl.base.attributes.access.lists.AclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.SubinterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.IetfAcl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.ietf.acl.Ingress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.base.attributes.ietf.acl.IngressBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class SubInterfaceIetfAclCustomizerTest extends WriterCustomizerTest {
+
+    private static final String IFC_TEST_INSTANCE = "ifc-test-instance";
+    private static final String IF_NAME = "local0";
+    private static final int IF_INDEX = 1;
+    private static final String SUBIF_NAME = "local0.123";
+    private static final int SUBIF_INDEX = 2;
+    private static final long SUB_IF_ID = 123;
+    private static final InstanceIdentifier<Ingress> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IF_NAME)).augmentation(
+            SubinterfaceAugmentation.class).child(SubInterfaces.class)
+            .child(SubInterface.class, new SubInterfaceKey(SUB_IF_ID)).child(IetfAcl.class).child(Ingress.class);
+    private static final String ACL_NAME = "acl1";
+    private static final Class<? extends AclBase> ACL_TYPE = EthAcl.class;
+
+    private SubInterfaceIetfAclCustomizer customizer;
+    private Ingress acl;
+
+    @Mock
+    private AclTableContextManager aclCtx;
+
+    @Override
+    protected void setUp() {
+        customizer =
+            new SubInterfaceIetfAclCustomizer(new IngressIetfAclWriter(api, aclCtx), new NamingContext("prefix", IFC_TEST_INSTANCE));
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+
+        acl = new IngressBuilder().setAccessLists(
+            new AccessListsBuilder().setAcl(
+                Collections.singletonList(new AclBuilder()
+                    .setName(ACL_NAME)
+                    .setType(ACL_TYPE)
+                    .build())
+            ).build()
+        ).build();
+    }
+
+    private static InputAclSetInterface inputAclSetInterfaceWriteRequest() {
+        final InputAclSetInterface request = new InputAclSetInterface();
+        request.swIfIndex = SUBIF_INDEX;
+        request.isAdd = 1;
+        request.l2TableIndex = -1;
+        request.ip4TableIndex = -1;
+        request.ip6TableIndex = -1;
+        return request;
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+        defineMapping(mappingContext, SUBIF_NAME, SUBIF_INDEX, IFC_TEST_INSTANCE);
+        when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply()));
+        when(aclCtx.getEntry(SUBIF_INDEX, mappingContext)).thenReturn(Optional.of(
+            new MappingEntryBuilder()
+                .setIndex(SUBIF_INDEX)
+                .setL2TableId(-1)
+                .setIp4TableId(-1)
+                .setIp6TableId(-1)
+                .build()));
+
+        customizer.deleteCurrentAttributes(IID, acl, writeContext);
+
+        final ClassifyTableByInterface expectedRequest = new ClassifyTableByInterface();
+        expectedRequest.swIfIndex = SUBIF_INDEX;
+        verify(api).inputAclSetInterface(inputAclSetInterfaceDeleteRequest());
+    }
+
+    private static InputAclSetInterface inputAclSetInterfaceDeleteRequest() {
+        final InputAclSetInterface request = new InputAclSetInterface();
+        request.swIfIndex = SUBIF_INDEX;
+        request.l2TableIndex = -1;
+        request.ip4TableIndex = -1;
+        request.ip6TableIndex = -1;
+        return request;
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        defineMapping(mappingContext, IF_NAME, IF_INDEX, IFC_TEST_INSTANCE);
+        defineMapping(mappingContext, SUBIF_NAME, SUBIF_INDEX, IFC_TEST_INSTANCE);
+
+        when(writeContext.readAfter(IID.firstIdentifierOf(SubInterface.class))).thenReturn(Optional.of(
+            new SubInterfaceBuilder().build()
+        ));
+
+        when(writeContext.readAfter(IetfAclWriter.ACL_ID.child(
+            org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl.class,
+            new AclKey(ACL_NAME, ACL_TYPE)))).thenReturn(Optional.of(
+            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclBuilder()
+                .setAccessListEntries(
+                    new AccessListEntriesBuilder().setAce(Collections.emptyList()).build()
+                ).build()
+        ));
+
+        when(api.inputAclSetInterface(any())).thenReturn(future(new InputAclSetInterfaceReply()));
+
+        customizer.writeCurrentAttributes(IID, acl, writeContext);
+
+        verify(api).inputAclSetInterface(inputAclSetInterfaceWriteRequest());
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/Ipv4AddressCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/Ipv4AddressCustomizerTest.java
new file mode 100644
index 000000000..6659e79b6
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/Ipv4AddressCustomizerTest.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.ip;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.v3po.interfaces.ip.subnet.validation.SubnetValidationException;
+import io.fd.hc2vpp.v3po.interfaces.ip.subnet.validation.SubnetValidator;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+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.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.Netmask;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.NetmaskBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLength;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLengthBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceAddDelAddress;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceAddDelAddressReply;
+
+public class Ipv4AddressCustomizerTest extends WriterCustomizerTest {
+
+    private static final String IFC_CTX_NAME = "ifc-test-instance";
+    private static final String IFACE_NAME = "eth0";
+    private static final int IFACE_ID = 123;
+
+    @Mock
+    private SubnetValidator subnetValidator;
+
+    private NamingContext interfaceContext;
+    private Ipv4AddressCustomizer customizer;
+
+    @Before
+    public void setUp() throws Exception {
+        interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME);
+
+        customizer = new Ipv4AddressCustomizer(api, interfaceContext, subnetValidator);
+
+        doReturn(future(new IpAddressDetailsReplyDump())).when(api).ipAddressDump(any());
+        when(writeContext.readAfter(Mockito.any()))
+                .thenReturn(Optional.of(new Ipv4Builder().setAddress(Collections.emptyList()).build()));
+    }
+
+    private static InstanceIdentifier<Address> getAddressId(final String ifaceName) {
+        return InstanceIdentifier.builder(Interfaces.class)
+                .child(Interface.class, new InterfaceKey(ifaceName))
+                .augmentation(Interface1.class)
+                .child(Ipv4.class)
+                .child(Address.class)
+                .build();
+    }
+
+    private void whenSwInterfaceAddDelAddressThenSuccess() {
+        doReturn(future(new SwInterfaceAddDelAddressReply())).when(api).swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
+    }
+
+    private void whenSwInterfaceAddDelAddressThenFailure() {
+        doReturn(failedFuture()).when(api).swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
+    }
+
+    @Test
+    public void testAddPrefixLengthIpv4Address() throws Exception {
+        doNothing().when(subnetValidator).checkNotAddingToSameSubnet(Mockito.anyList());
+
+        final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+        when(writeContext.readBefore(id)).thenReturn(Optional.absent());
+
+        Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
+        Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
+
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+        whenSwInterfaceAddDelAddressThenSuccess();
+
+        customizer.writeCurrentAttributes(id, data, writeContext);
+
+        verify(api).swInterfaceAddDelAddress(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+                (byte) 1, (byte) 24));
+    }
+
+    @Test
+    public void testAddPrefixLengthIpv4AddressFailed() throws Exception {
+        final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+        when(writeContext.readBefore(id)).thenReturn(Optional.absent());
+
+        Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
+        Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
+
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+        whenSwInterfaceAddDelAddressThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(id, data, writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceAddDelAddress(
+                    generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+                            (byte) 1, (byte) 24));
+            return;
+        }
+        fail("WriteFailedException was expected");
+    }
+
+    @Test
+    public void testAddPrefixLengthIpv4AddressConflicted() throws Exception {
+
+        final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+        when(writeContext.readBefore(id)).thenReturn(Optional.absent());
+
+        Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
+        Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
+        final List<Address> addressList = Arrays.asList(data);
+
+        //throws when validation invoked
+        Mockito.doThrow(SubnetValidationException.forConflictingData((short) 24, Arrays.asList(data))).when(subnetValidator)
+                .checkNotAddingToSameSubnet(addressList);
+
+        //fake data return from WriteContext
+        doReturn(Optional.of(new Ipv4Builder().setAddress(addressList).build())).when(writeContext)
+                .readAfter(argThat(matchInstanceIdentifier(Ipv4.class)));
+
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+
+        try {
+            customizer.writeCurrentAttributes(id, data, writeContext);
+        } catch (WriteFailedException e) {
+            //verifies if cause of exception is correct type
+            assertTrue(e.getCause() instanceof SubnetValidationException);
+
+            //verify that validation call was invoked with data from writeContext
+            verify(subnetValidator, times(1)).checkNotAddingToSameSubnet(addressList);
+        }
+
+    }
+
+    private static ArgumentMatcher<InstanceIdentifier<?>> matchInstanceIdentifier(
+            Class<?> desiredClass) {
+        return o -> o instanceof InstanceIdentifier && (o.getTargetType().equals(desiredClass));
+    }
+
+    @Test(expected =  WriteFailedException.UpdateFailedException.class)
+    public void testUpdate() throws Exception {
+        final Address data = mock(Address.class);
+        customizer.updateCurrentAttributes(getAddressId(IFACE_NAME), data, data, writeContext);
+    }
+
+    private SwInterfaceAddDelAddress generateSwInterfaceAddDelAddressRequest(final byte[] address, final byte isAdd,
+                                                                             final byte prefixLength) {
+        final SwInterfaceAddDelAddress request = new SwInterfaceAddDelAddress();
+        request.swIfIndex = IFACE_ID;
+        request.isAdd = isAdd;
+        request.isIpv6 = 0;
+        request.delAll = 0;
+        request.addressLength = prefixLength;
+        request.address = address;
+        return request;
+    }
+
+    @Test
+    public void testDeletePrefixLengthIpv4Address() throws Exception {
+        final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+
+        Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
+        Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
+
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+        whenSwInterfaceAddDelAddressThenSuccess();
+
+        customizer.deleteCurrentAttributes(id, data, writeContext);
+
+        verify(api).swInterfaceAddDelAddress(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+                (byte) 0, (byte) 24));
+    }
+
+    @Test
+    public void testDeletePrefixLengthIpv4AddressFailed() throws Exception {
+        final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+
+        Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
+        Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
+
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+        whenSwInterfaceAddDelAddressThenFailure();
+
+        try {
+            customizer.deleteCurrentAttributes(id, data, writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceAddDelAddress(
+                    generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+                            (byte) 0, (byte) 24));
+            return;
+        }
+        fail("WriteFailedException was expec16ted");
+    }
+
+    @Test
+    public void testNetmaskFailed() {
+        final int expectedPrefixLength = 1;
+        final String stringMask = "128.0.0.0";
+        final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+        when(writeContext.readBefore(id)).thenReturn(Optional.absent());
+
+        Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        Netmask subnet = new NetmaskBuilder().setNetmask(new DottedQuad(stringMask)).build();
+        Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
+
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+        whenSwInterfaceAddDelAddressThenFailure();
+
+        try {
+            customizer.writeCurrentAttributes(id, data, writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceAddDelAddress(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+                (byte) 1, (byte) expectedPrefixLength));
+            return;
+        }
+        fail("WriteFailedException was expec16ted");
+
+    }
+
+    private void testSingleNetmask(final int expectedPrefixLength, final String stringMask) throws Exception {
+        final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+        when(writeContext.readBefore(id)).thenReturn(Optional.absent());
+
+        Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        Netmask subnet = new NetmaskBuilder().setNetmask(new DottedQuad(stringMask)).build();
+        Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
+
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+        whenSwInterfaceAddDelAddressThenSuccess();
+
+        customizer.writeCurrentAttributes(id, data, writeContext);
+
+        verify(api).swInterfaceAddDelAddress(generateSwInterfaceAddDelAddressRequest(new byte[]{-64, -88, 2, 1},
+            (byte) 1, (byte) expectedPrefixLength));
+    }
+
+    private void testSingleIllegalNetmask(final String stringMask) throws Exception {
+        try {
+            final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
+            when(writeContext.readBefore(id)).thenReturn(Optional.absent());
+
+            Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+            Netmask subnet = new NetmaskBuilder().setNetmask(new DottedQuad(stringMask)).build();
+            Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
+
+            defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+            whenSwInterfaceAddDelAddressThenSuccess();
+
+            customizer.writeCurrentAttributes(id, data, writeContext);
+        } catch (IllegalArgumentException e) {
+            return;
+        }
+        fail("IllegalArgumentException expected");
+
+    }
+
+    /**
+     * Test contiguous netmask length from QuadDotted notation
+     */
+    @Test
+    public void testNetmaskLength() throws Exception {
+        testSingleNetmask(1, "128.0.0.0");
+        testSingleNetmask(2, "192.0.0.0");
+        testSingleNetmask(8, "255.0.0.0");
+        testSingleNetmask(9, "255.128.0.0");
+        testSingleNetmask(16, "255.255.0.0");
+        testSingleNetmask(24, "255.255.255.0");
+    }
+
+    @Test
+    public void testNetmaskIllegal() throws Exception {
+        testSingleIllegalNetmask("");
+        testSingleIllegalNetmask(".");
+        testSingleIllegalNetmask(".255");
+        testSingleIllegalNetmask("255");
+        testSingleIllegalNetmask("255.");
+        testSingleIllegalNetmask("255.255");
+        testSingleIllegalNetmask("255.255.0");
+        testSingleIllegalNetmask("255.255.255.");
+        testSingleIllegalNetmask("255.255.255.256");
+        testSingleIllegalNetmask("0.0.0.0");
+        testSingleIllegalNetmask("10.10.10.10");
+        testSingleIllegalNetmask("255.1.255.0");
+        testSingleIllegalNetmask("255.255.255.255");
+    }
+}
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/Ipv4NeighbourCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/Ipv4NeighbourCustomizerTest.java
new file mode 100644
index 000000000..390561d80
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/Ipv4NeighbourCustomizerTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.ip;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+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.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Neighbor;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.NeighborBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.IpNeighborAddDel;
+import io.fd.vpp.jvpp.core.dto.IpNeighborAddDelReply;
+
+public class Ipv4NeighbourCustomizerTest extends WriterCustomizerTest implements Ipv4Translator {
+
+    private static final String IFC_CTX_NAME = "ifc-test-instance";
+    private static final String IFACE_NAME = "parent";
+    private static final int IFACE_ID = 5;
+    private static final InstanceIdentifier<Neighbor> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME))
+            .augmentation(Interface1.class).child(Ipv4.class).child(Neighbor.class);
+
+    private Ipv4NeighbourCustomizer customizer;
+
+    @Override
+    public void setUp() {
+        defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
+        customizer = new Ipv4NeighbourCustomizer(api, new NamingContext("prefix", IFC_CTX_NAME));
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws WriteFailedException {
+        when(api.ipNeighborAddDel(any())).thenReturn(future(new IpNeighborAddDelReply()));
+        customizer.writeCurrentAttributes(IID, getData(), writeContext);
+        verify(api).ipNeighborAddDel(getExpectedRequest(true));
+    }
+
+    @Test
+    public void testWriteCurrentAttributesFailed() {
+        when(api.ipNeighborAddDel(any())).thenReturn(failedFuture());
+        try {
+            customizer.writeCurrentAttributes(IID, getData(), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).ipNeighborAddDel(getExpectedRequest(true));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdateCurrentAttributes() throws WriteFailedException {
+        customizer.updateCurrentAttributes(IID, getData(), getData(), writeContext);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws WriteFailedException {
+        when(api.ipNeighborAddDel(any())).thenReturn(future(new IpNeighborAddDelReply()));
+        customizer.deleteCurrentAttributes(IID, getData(), writeContext);
+        verify(api).ipNeighborAddDel(getExpectedRequest(false));
+    }
+
+    @Test
+    public void testDeleteCurrentAttributesFailed() {
+        when(api.ipNeighborAddDel(any())).thenReturn(failedFuture());
+        try {
+            customizer.deleteCurrentAttributes(IID, getData(), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).ipNeighborAddDel(getExpectedRequest(false));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+
+    private Neighbor getData() {
+        final Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        final PhysAddress mac = new PhysAddress("aa:bb:cc:ee:11:22");
+        return new NeighborBuilder().setIp(noZoneIp).setLinkLayerAddress(mac).build();
+    }
+    private IpNeighborAddDel getExpectedRequest(final boolean isAdd) {
+        final IpNeighborAddDel request = new IpNeighborAddDel();
+        request.isIpv6 = 0;
+        request.isAdd = booleanToByte(isAdd);
+        request.isStatic = 1;
+        request.dstAddress = new byte[] {(byte) 192, (byte) 168, 2, 1};
+        request.macAddress = new byte[] {(byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xee, 0x11, 0x22};
+        request.swIfIndex = IFACE_ID;
+        return request;
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/SubInterfaceIpv4AddressCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/SubInterfaceIpv4AddressCustomizerTest.java
new file mode 100644
index 000000000..be0869fa9
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/SubInterfaceIpv4AddressCustomizerTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.ip;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import org.junit.Test;
+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.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.SubinterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.AddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.address.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.address.subnet.Netmask;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.address.subnet.NetmaskBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.address.subnet.PrefixLength;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.address.subnet.PrefixLengthBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceAddDelAddress;
+import io.fd.vpp.jvpp.core.dto.SwInterfaceAddDelAddressReply;
+
+public class SubInterfaceIpv4AddressCustomizerTest extends WriterCustomizerTest implements ByteDataTranslator {
+
+    private static final String IFC_CTX_NAME = "ifc-test-instance";
+    private static final String IFACE_NAME = "eth0";
+    private static final int IFACE_INDEX = 0;
+    private static final String SUBIF_NAME = "eth0.1";
+    private static final long SUBIF_ID = 1;
+    private static final int SUBIF_INDEX = 123;
+    private static final InstanceIdentifier<Address> IID =
+        InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME))
+            .augmentation(SubinterfaceAugmentation.class).child(SubInterfaces.class)
+            .child(SubInterface.class, new SubInterfaceKey(SUBIF_ID)).child(Ipv4.class).child(Address.class);
+
+    private SubInterfaceIpv4AddressCustomizer customizer;
+
+    @Override
+    protected void setUp() {
+        customizer = new SubInterfaceIpv4AddressCustomizer(api, new NamingContext("prefix", IFC_CTX_NAME));
+        defineMapping(mappingContext, IFACE_NAME, IFACE_INDEX, IFC_CTX_NAME);
+        defineMapping(mappingContext, SUBIF_NAME, SUBIF_INDEX, IFC_CTX_NAME);
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        when(api.swInterfaceAddDelAddress(any())).thenReturn(future(new SwInterfaceAddDelAddressReply()));
+        customizer.writeCurrentAttributes(IID, address(prefixLength()), writeContext);
+        verify(api).swInterfaceAddDelAddress(expectedRequest(true));
+    }
+
+    @Test
+    public void testWriteFailed() {
+        when(api.swInterfaceAddDelAddress(any())).thenReturn(failedFuture());
+        try {
+            customizer.writeCurrentAttributes(IID, address(prefixLength()), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceAddDelAddress(expectedRequest(true));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        when(api.swInterfaceAddDelAddress(any())).thenReturn(future(new SwInterfaceAddDelAddressReply()));
+        customizer.deleteCurrentAttributes(IID, address(netmask()), writeContext);
+        verify(api).swInterfaceAddDelAddress(expectedRequest(false));
+    }
+
+    @Test
+    public void testDeleteFailed() {
+        when(api.swInterfaceAddDelAddress(any())).thenReturn(failedFuture());
+        try {
+            customizer.deleteCurrentAttributes(IID, address(netmask()), writeContext);
+        } catch (WriteFailedException e) {
+            assertTrue(e.getCause() instanceof VppBaseCallException);
+            verify(api).swInterfaceAddDelAddress(expectedRequest(false));
+            return;
+        }
+        fail("WriteFailedException expected");
+    }
+
+    private SwInterfaceAddDelAddress expectedRequest(boolean isAdd) {
+        final SwInterfaceAddDelAddress request = new SwInterfaceAddDelAddress();
+        request.isAdd = booleanToByte(isAdd);
+        request.swIfIndex = SUBIF_INDEX;
+        request.isIpv6 = 0;
+        request.delAll = 0;
+        request.addressLength = 24;
+        request.address = new byte[] {(byte) 192, (byte) 168, 2, 1};
+        return request;
+    }
+
+    @Test(expected = WriteFailedException.UpdateFailedException.class)
+    public void testUpdate() throws Exception {
+        final Address address = address(prefixLength());
+        customizer.updateCurrentAttributes(IID, address, address, writeContext);
+    }
+
+    private Address address(final Subnet subnet) {
+        final Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
+        return new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
+    }
+
+    private PrefixLength prefixLength() {
+        return new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
+    }
+
+    private Netmask netmask() {
+        return new NetmaskBuilder().setNetmask(new DottedQuad("255.255.255.0")).build();
+    }
+}
\ No newline at end of file
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/subnet/validation/SubnetValidatorTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/subnet/validation/SubnetValidatorTest.java
new file mode 100644
index 000000000..0c1e878a8
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/ip/subnet/validation/SubnetValidatorTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.ip.subnet.validation;
+
+
+import com.google.common.collect.Lists;
+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.ip.rev140616.interfaces._interface.ipv4.Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.NetmaskBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLengthBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
+
+public class SubnetValidatorTest {
+
+    private SubnetValidator subnetValidator;
+
+    @Before
+    public void init() {
+        subnetValidator = new SubnetValidator();
+    }
+
+    @Test(expected = SubnetValidationException.class)
+    public void testValidateNegativeSameTypes() throws SubnetValidationException {
+        List<Address> addresses = Lists.newArrayList();
+
+        addresses.add(new AddressBuilder().setSubnet(new PrefixLengthBuilder().setPrefixLength((short) 24).build())
+                .build());
+        addresses.add(new AddressBuilder().setSubnet(new PrefixLengthBuilder().setPrefixLength((short) 24).build())
+                .build());
+
+        subnetValidator.checkNotAddingToSameSubnet(addresses);
+    }
+
+    @Test(expected = SubnetValidationException.class)
+    public void testValidateNegativeMixedTypes() throws SubnetValidationException {
+        List<Address> addresses = Lists.newArrayList();
+
+        addresses.add(new AddressBuilder().setSubnet(new PrefixLengthBuilder().setPrefixLength((short) 24).build())
+                .build());
+        addresses.add(new AddressBuilder()
+                .setSubnet(new NetmaskBuilder().setNetmask(new DottedQuad("255.255.255.0")).build())
+                .build());
+
+        subnetValidator.checkNotAddingToSameSubnet(addresses);
+    }
+
+    @Test
+    public void testValidatePositiveSameTypes() throws SubnetValidationException {
+        List<Address> addresses = Lists.newArrayList();
+
+        addresses.add(new AddressBuilder().setSubnet(new PrefixLengthBuilder().setPrefixLength((short) 24).build())
+                .build());
+        addresses.add(new AddressBuilder().setSubnet(new PrefixLengthBuilder().setPrefixLength((short) 25).build())
+                .build());
+
+        subnetValidator.checkNotAddingToSameSubnet(addresses);
+    }
+
+    @Test
+    public void testValidatePositiveMixedTypes() throws SubnetValidationException {
+        List<Address> addresses = Lists.newArrayList();
+
+        addresses.add(new AddressBuilder().setSubnet(new PrefixLengthBuilder().setPrefixLength((short) 24).build())
+                .build());
+        addresses.add(new AddressBuilder()
+                .setSubnet(new NetmaskBuilder().setNetmask(new DottedQuad("255.255.0.0")).build())
+                .build());
+
+        subnetValidator.checkNotAddingToSameSubnet(addresses);
+    }
+}
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java
new file mode 100644
index 000000000..fa68e61b6
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/hc2vpp/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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 io.fd.hc2vpp.v3po.interfaces.pbb;
+
+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 static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.hc2vpp.common.test.write.WriterCustomizerTest;
+import io.fd.vpp.jvpp.VppCallbackException;
+import io.fd.vpp.jvpp.core.dto.L2InterfacePbbTagRewrite;
+import io.fd.vpp.jvpp.core.dto.L2InterfacePbbTagRewriteReply;
+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.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+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.pbb.types.rev161214.Operation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.pbb.rev161214.PbbRewriteInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewrite;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewriteBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class PbbRewriteCustomizerTest extends WriterCustomizerTest {
+
+    @Captor
+    private ArgumentCaptor<L2InterfacePbbTagRewrite> rewriteArgumentCaptor;
+
+    private NamingContext interfaceContext;
+    private PbbRewriteCustomizer customizer;
+    private InstanceIdentifier<PbbRewrite> validId;
+    private InstanceIdentifier<PbbRewrite> invalidId;
+
+    @Override
+    protected void setUp() throws Exception {
+        interfaceContext = new NamingContext("interface", "interface-context");
+        customizer = new PbbRewriteCustomizer(api, interfaceContext);
+
+        defineMapping(mappingContext, "pbb-interface", 1, "interface-context");
+        validId = InstanceIdentifier.create(Interfaces.class)
+                .child(Interface.class, new InterfaceKey("pbb-interface"))
+                .augmentation(PbbRewriteInterfaceAugmentation.class)
+                .child(PbbRewrite.class);
+
+        invalidId = InstanceIdentifier.create(PbbRewrite.class);
+    }
+
+    @Test
+    public void testWrite() throws WriteFailedException {
+        whenRewriteThenSuccess();
+        customizer.writeCurrentAttributes(validId, validData(), writeContext);
+        verifyRewriteRequest(desiredSetResult());
+    }
+
+    @Test
+    public void testWriteFailedCallFailed() {
+        whenRewriteThenFail();
+        final PbbRewrite validData = validData();
+        try {
+            customizer.writeCurrentAttributes(validId, validData, writeContext);
+        } catch (Exception e) {
+            assertTrue(e instanceof WriteFailedException.CreateFailedException);
+            assertTrue(e.getCause() instanceof VppCallbackException);
+
+            final WriteFailedException.CreateFailedException ex = ((WriteFailedException.CreateFailedException) e);
+            assertEquals(validId, ex.getFailedId());
+            assertEquals(validData, ex.getData());
+            return;
+        }
+
+        fail("Test should have failed");
+    }
+
+    @Test
+    public void testWriteFailedInvalidData() {
+        verifyInvalidWriteDataCombination(invalidDataNoDestination());
+        verifyInvalidWriteDataCombination(invalidDataNoSource());
+        verifyInvalidWriteDataCombination(invalidDataNoItag());
+        verifyInvalidWriteDataCombination(invalidDataNoOperation());
+        verifyInvalidWriteDataCombination(invalidDataNoVlan());
+    }
+
+    @Test
+    public void testUpdate() throws WriteFailedException {
+        whenRewriteThenSuccess();
+        final PbbRewrite rewrite = validData();
+        customizer.updateCurrentAttributes(validId, rewrite, rewrite, writeContext);
+        verifyRewriteRequest(desiredSetResult());
+    }
+
+    @Test
+    public void testUpdateFailedCallFailed() {
+        whenRewriteThenFail();
+        final PbbRewrite invalidData = invalidDataNoVlan();
+        final PbbRewrite validData = validData();
+        try {
+            customizer.updateCurrentAttributes(validId, invalidData, validData, writeContext);
+        } catch (Exception e) {
+            assertTrue(e instanceof WriteFailedException.UpdateFailedException);
+            assertTrue(e.getCause() instanceof VppCallbackException);
+
+            final WriteFailedException.UpdateFailedException ex = ((WriteFailedException.UpdateFailedException) e);
+            assertEquals(validId, ex.getFailedId());
+            assertEquals(invalidData, ex.getDataBefore());
+            assertEquals(validData, ex.getDataAfter());
+            return;
+        }
+
+        fail("Test should have failed");
+    }
+
+    @Test
+    public void testUpdateFailedInvalidData() {
+        verifyInvalidUpdateDataCombination(invalidDataNoDestination());
+        verifyInvalidUpdateDataCombination(invalidDataNoSource());
+        verifyInvalidUpdateDataCombination(invalidDataNoItag());
+        verifyInvalidUpdateDataCombination(invalidDataNoOperation());
+        verifyInvalidUpdateDataCombination(invalidDataNoVlan());
+    }
+
+    @Test
+    public void testDelete() throws WriteFailedException {
+        whenRewriteThenSuccess();
+        customizer.deleteCurrentAttributes(validId, validData(), writeContext);
+        verifyRewriteRequest(desiredDisableResult());
+    }
+
+    @Test
+    public void testDeleteFailedCallFailed() {
+        whenRewriteThenFail();
+        final PbbRewrite validData = validData();
+        try {
+            customizer.deleteCurrentAttributes(validId, validData, writeContext);
+        } catch (Exception e) {
+            assertTrue(e instanceof WriteFailedException.DeleteFailedException);
+            assertTrue(e.getCause() instanceof VppCallbackException);
+            assertEquals(validId, ((WriteFailedException.DeleteFailedException) e).getFailedId());
+            return;
+        }
+
+        fail("Test should have failed");
+    }
+
+    @Test
+    public void testDeleteFailedInvalidData() {
+        verifyInvalidDeleteDataCombination(invalidDataNoDestination());
+        verifyInvalidDeleteDataCombination(invalidDataNoSource());
+        verifyInvalidDeleteDataCombination(invalidDataNoItag());
+        verifyInvalidDeleteDataCombination(invalidDataNoOperation());
+        verifyInvalidDeleteDataCombination(invalidDataNoVlan());
+    }
+
+    private void whenRewriteThenSuccess() {
+        when(api.l2InterfacePbbTagRewrite(any())).thenReturn(future(new L2InterfacePbbTagRewriteReply()));
+    }
+
+    private void whenRewriteThenFail() {
+        when(api.l2InterfacePbbTagRewrite(any())).thenReturn(failedFuture());
+    }
+
+    private void verifyInvalidWriteDataCombination(final PbbRewrite invalidData) {
+        try {
+            customizer.writeCurrentAttributes(validId, invalidData, writeContext);
+        } catch (Exception e) {
+            assertTrue(e instanceof NullPointerException);
+            return;
+        }
+
+        fail("Verifying of invalid combination failed");
+    }
+
+    private void verifyInvalidUpdateDataCombination(final PbbRewrite invalidData) {
+        try {
+            customizer.updateCurrentAttributes(validId, validData(), invalidData, writeContext);
+        } catch (Exception e) {
+            assertTrue(e instanceof NullPointerException);
+            return;
+        }
+
+        fail("Verifying of invalid combination failed");
+    }
+
+
+    private void verifyInvalidDeleteDataCombination(final PbbRewrite invalidData) {
+        try {
+            customizer.deleteCurrentAttributes(validId, invalidData, writeContext);
+        } catch (Exception e) {
+            assertTrue(e instanceof NullPointerException);
+            return;
+        }
+
+        fail("Verifying of invalid combination failed");
+    }
+
+
+    private L2InterfacePbbTagRewrite desiredSetResult() {
+        final L2InterfacePbbTagRewrite desiredResult = new L2InterfacePbbTagRewrite();
+        desiredResult.swIfIndex = 1;
+        desiredResult.vtrOp = Operation.Pop2.getIntValue();
+        desiredResult.bDmac = new byte[]{-69, -69, -69, -69, -69, -69};
+        desiredResult.bSmac = new byte[]{-86, -86, -86, -86, -86, -86};
+        desiredResult.bVlanid = 1;
+        desiredResult.iSid = 2;
+
+        return desiredResult;
+    }
+
+    private L2InterfacePbbTagRewrite desiredDisableResult() {
+        final L2InterfacePbbTagRewrite desiredResult = new L2InterfacePbbTagRewrite();
+        desiredResult.swIfIndex = 1;
+        desiredResult.vtrOp = 0;
+        desiredResult.bDmac = new byte[]{-69, -69, -69, -69, -69, -69};
+        desiredResult.bSmac = new byte[]{-86, -86, -86, -86, -86, -86};
+        desiredResult.bVlanid = 1;
+        desiredResult.iSid = 2;
+
+        return desiredResult;
+    }
+
+    private void verifyRewriteRequest(final L2InterfacePbbTagRewrite desiredResult) {
+        verify(api, times(1)).l2InterfacePbbTagRewrite(rewriteArgumentCaptor.capture());
+
+        final L2InterfacePbbTagRewrite actualRequest = rewriteArgumentCaptor.getValue();
+
+        assertNotNull(actualRequest);
+        assertEquals(actualRequest.bVlanid, desiredResult.bVlanid);
+        assertEquals(actualRequest.iSid, desiredResult.iSid);
+        assertEquals(actualRequest.vtrOp, desiredResult.vtrOp);
+        assertEquals(actualRequest.outerTag, desiredResult.outerTag);
+        assertArrayEquals(actualRequest.bDmac, desiredResult.bDmac);
+        assertArrayEquals(actualRequest.bSmac, desiredResult.bSmac);
+    }
+
+    private PbbRewrite invalidDataNoDestination() {
+        return new PbbRewriteBuilder()
+                .setBVlanTagVlanId(1)
+                .setITagIsid(2L)
+                .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
+                .setInterfaceOperation(Operation.Pop2)
+                .build();
+    }
+
+    private PbbRewrite invalidDataNoSource() {
+        return new PbbRewriteBuilder()
+                .setBVlanTagVlanId(1)
+                .setITagIsid(2L)
+                .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
+                .setInterfaceOperation(Operation.Pop2)
+                .build();
+    }
+
+    private PbbRewrite invalidDataNoItag() {
+        return new PbbRewriteBuilder()
+                .setBVlanTagVlanId(1)
+                .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
+                .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
+                .setInterfaceOperation(Operation.Pop2)
+                .build();
+    }
+
+    private PbbRewrite invalidDataNoVlan() {
+        return new PbbRewriteBuilder()
+                .setITagIsid(2L)
+                .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
+                .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
+                .setInterfaceOperation(Operation.Pop2)
+                .build();
+    }
+
+    private PbbRewrite invalidDataNoOperation() {
+        return new PbbRewriteBuilder()
+                .setITagIsid(2L)
+                .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
+                .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
+                .setInterfaceOperation(Operation.Pop2)
+                .build();
+    }
+
+    private PbbRewrite validData() {
+        return new PbbRewriteBuilder()
+                .setBVlanTagVlanId(1)
+                .setITagIsid(2L)
+                .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
+                .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
+                .setInterfaceOperation(Operation.Pop2)
+                .build();
+    }
+}