HONEYCOMB-8: Move data layer from impl module into submodules

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

8 files changed, 2 insertions, 930 deletions

diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/DataTreeUtilsTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/DataTreeUtilsTest.java
deleted file mode 100644
index 7f1db5118..000000000
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/DataTreeUtilsTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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.honeycomb.v3po.impl.data;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Map;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-
-public class DataTreeUtilsTest {
-
-    @Test
-    public void testChildrenFromNormalized() throws Exception {
-        final ContainerNode parent = mock(ContainerNode.class);
-        final BindingNormalizedNodeSerializer serializer = mock(BindingNormalizedNodeSerializer.class);
-
-        final Collection<DataContainerChild> list = new ArrayList<>();
-        doReturn(list).when(parent).getValue();
-
-        // init child1 (will not be serialized)
-        final DataContainerChild child1 = Mockito.mock(DataContainerChild.class);
-        when(child1.getIdentifier()).thenReturn(mock(YangInstanceIdentifier.PathArgument.class));
-        when(serializer.fromNormalizedNode(any(YangInstanceIdentifier.class), eq(child1))).thenReturn(null);
-        list.add(child1);
-
-        // init child 2 (will be serialized)
-        final DataContainerChild child2 = mock(DataContainerChild.class);
-        when(child2.getIdentifier()).thenReturn(mock(YangInstanceIdentifier.PathArgument.class));
-
-        final Map.Entry entry = mock(Map.Entry.class);
-        final InstanceIdentifier<?> id = mock(InstanceIdentifier.class);
-        doReturn(id).when(entry).getKey();
-        final DataObject data = mock(DataObject.class);
-        doReturn(data).when(entry).getValue();
-        when(serializer.fromNormalizedNode(any(YangInstanceIdentifier.class), eq(child2))).thenReturn(entry);
-
-        list.add(child2);
-
-        // run tested method
-        final Map<InstanceIdentifier<?>, DataObject> map = DataTreeUtils.childrenFromNormalized(parent, serializer);
-        assertEquals(1, map.size());
-        assertEquals(data, map.get(id));
-    }
-}
\ No newline at end of file
diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/ReadWriteTransactionTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/ReadWriteTransactionTest.java
deleted file mode 100644
index f0fd66de5..000000000
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/ReadWriteTransactionTest.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * 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.honeycomb.v3po.impl.data;
-
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-
-public class ReadWriteTransactionTest {
-
-    @Mock
-    private DOMDataReadOnlyTransaction readTx;
-
-    @Mock
-    private DOMDataWriteTransaction writeTx;
-
-    private LogicalDatastoreType store;
-
-    @Mock
-    private YangInstanceIdentifier path;
-
-    @Mock
-    private NormalizedNode<?, ?> data;
-
-    private ReadWriteTransaction readWriteTx;
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-        store = LogicalDatastoreType.CONFIGURATION;
-        readWriteTx = new ReadWriteTransaction(readTx, writeTx);
-    }
-
-    @Test
-    public void testCancel() {
-        readWriteTx.cancel();
-        verify(writeTx).cancel();
-    }
-
-    @Test
-    public void testPut() {
-        readWriteTx.put(store, path, data);
-        verify(writeTx).put(store, path, data);
-    }
-
-    @Test
-    public void testMerge() {
-        readWriteTx.merge(store, path, data);
-        verify(writeTx).merge(store, path, data);
-    }
-
-    @Test
-    public void testDelete() {
-        readWriteTx.delete(store, path);
-        verify(writeTx).delete(store, path);
-    }
-
-    @Test
-    public void testSubmit() throws Exception {
-        readWriteTx.submit();
-        verify(writeTx).submit();
-    }
-
-
-    @SuppressWarnings("deprecation")
-    @Test
-    public void testCommit() throws Exception {
-        readWriteTx.commit();
-        verify(writeTx).commit();
-    }
-
-    @Test
-    public void testRead() {
-        readWriteTx.read(store, path);
-        verify(readTx).read(store, path);
-    }
-
-    @Test
-    public void testExists() {
-        readWriteTx.exists(store, path);
-        verify(readTx).exists(store, path);
-    }
-
-    @Test
-    public void testGetIdentifier() throws Exception {
-        assertNotNull(readWriteTx.getIdentifier());
-    }
-}
\ No newline at end of file
diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VPPConfigDataTreeTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VPPConfigDataTreeTest.java
deleted file mode 100644
index c4315cd38..000000000
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VPPConfigDataTreeTest.java
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
- * 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.honeycomb.v3po.impl.data;
-
-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.anyMap;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import io.fd.honeycomb.v3po.translate.TranslationException;
-import io.fd.honeycomb.v3po.translate.write.WriteContext;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.Ethernet;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
-
-public class VPPConfigDataTreeTest {
-
-    @Mock
-    private WriterRegistry vppWriter;
-    @Mock
-    private BindingNormalizedNodeSerializer serializer;
-    @Mock
-    private DataTree dataTree;
-    @Mock
-    private DataTreeModification modification;
-
-    private VppConfigDataTree proxy;
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-        proxy = new VppConfigDataTree(serializer, dataTree, vppWriter);
-    }
-
-    @Test
-    public void testRead() throws Exception {
-        final DataTreeSnapshot snapshot = mock(DataTreeSnapshot.class);
-        when(dataTree.takeSnapshot()).thenReturn(snapshot);
-
-        final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
-        final Optional node = mock(Optional.class);
-        doReturn(node).when(snapshot).readNode(path);
-
-        final VppDataTreeSnapshot vppDataTreeSnapshot = proxy.takeSnapshot();
-        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
-                vppDataTreeSnapshot.read(path);
-
-        verify(dataTree).takeSnapshot();
-        verify(snapshot).readNode(path);
-
-        assertTrue(future.isDone());
-        assertEquals(node, future.get());
-    }
-
-    @Test
-    public void testNewModification() throws Exception {
-        final DataTreeSnapshot snapshot = mock(DataTreeSnapshot.class);
-        when(dataTree.takeSnapshot()).thenReturn(snapshot);
-
-        when(snapshot.newModification()).thenReturn(modification);
-
-        final VppDataTreeSnapshot vppDataTreeSnapshot = proxy.takeSnapshot();
-        final DataTreeModification newModification = vppDataTreeSnapshot.newModification();
-        verify(dataTree).takeSnapshot();
-        verify(snapshot).newModification();
-
-        assertEquals(modification, newModification);
-    }
-
-    @Test
-    public void testCommitSuccessful() throws Exception {
-        final DataObject dataBefore = mockDataObject("before", Ethernet.class);
-        final DataObject dataAfter = mockDataObject("after", Ethernet.class);
-
-        // Prepare modification:
-        final DataTreeCandidateNode rootNode = mockRootNode();
-        // data before:
-        final ContainerNode nodeBefore = mockContainerNode(dataBefore);
-        when(rootNode.getDataBefore()).thenReturn(Optional.<NormalizedNode<?, ?>>fromNullable(nodeBefore));
-        // data after:
-        final ContainerNode nodeAfter = mockContainerNode(dataAfter);
-        when(rootNode.getDataAfter()).thenReturn(Optional.<NormalizedNode<?, ?>>fromNullable(nodeAfter));
-
-        // Run the test
-        proxy.commit(modification);
-
-        // Verify all changes were processed:
-        verify(vppWriter).update(
-                mapOf(dataBefore, Ethernet.class),
-                mapOf(dataAfter, Ethernet.class),
-                any(WriteContext.class));
-
-        // Verify modification was validated
-        verify(dataTree).validate(modification);
-    }
-
-    private Map<InstanceIdentifier<?>, DataObject> mapOf(final DataObject dataBefore, final Class<Ethernet> type) {
-        return eq(
-                Collections.<InstanceIdentifier<?>, DataObject>singletonMap(InstanceIdentifier.create(type),
-                        dataBefore));
-    }
-
-    private DataObject mockDataObject(final String name, final Class<? extends DataObject> classToMock) {
-        final DataObject dataBefore = mock(classToMock, name);
-        doReturn(classToMock).when(dataBefore).getImplementedInterface();
-        return dataBefore;
-    }
-
-    @Test
-    public void testCommitUndoSuccessful() throws Exception {
-        // Prepare data changes:
-        final DataObject dataBefore = mockDataObject("before", Ethernet.class);
-        final DataObject dataAfter = mockDataObject("after", Ethernet.class);
-
-        final io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter reverter = mock(
-            io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.class);
-
-        // Fail on update:
-        final TranslationException failedOnUpdateException = new TranslationException("update failed");
-        doThrow(new io.fd.honeycomb.v3po.translate.write.WriterRegistry.BulkUpdateException(InstanceIdentifier.create(Ethernet.class), reverter,
-                failedOnUpdateException)).when(vppWriter).update(anyMap(), anyMap(), any(WriteContext.class));
-
-        // Prepare modification:
-        final DataTreeCandidateNode rootNode = mockRootNode();
-        // data before:
-        final ContainerNode nodeBefore = mockContainerNode(dataBefore);
-        when(rootNode.getDataBefore()).thenReturn(Optional.<NormalizedNode<?, ?>>fromNullable(nodeBefore));
-        // data after:
-        final ContainerNode nodeAfter = mockContainerNode(dataAfter);
-        when(rootNode.getDataAfter()).thenReturn(Optional.<NormalizedNode<?, ?>>fromNullable(nodeAfter));
-
-        // Run the test
-        try {
-            proxy.commit(modification);
-        } catch (io.fd.honeycomb.v3po.translate.write.WriterRegistry.BulkUpdateException e) {
-            verify(vppWriter).update(anyMap(), anyMap(), any(WriteContext.class));
-            verify(reverter).revert();
-            assertEquals(failedOnUpdateException, e.getCause());
-            return;
-        }
-
-        fail("WriterRegistry.BulkUpdateException was expected");
-    }
-
-    @Test
-    public void testCommitUndoFailed() throws Exception {
-        // Prepare data changes:
-        final DataObject dataBefore = mockDataObject("before", Ethernet.class);
-        final DataObject dataAfter = mockDataObject("after", Ethernet.class);
-
-        final io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter reverter = mock(
-            io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.class);
-
-        // Fail on update:
-        doThrow(new io.fd.honeycomb.v3po.translate.write.WriterRegistry.BulkUpdateException(InstanceIdentifier.create(Ethernet.class), reverter,
-                new TranslationException("update failed"))).when(vppWriter).update(anyMap(), anyMap(), any(WriteContext.class));
-
-        // Fail on revert:
-        final TranslationException failedOnRevertException = new TranslationException("update failed");
-        final io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.RevertFailedException revertFailedException =
-                new io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.RevertFailedException(Collections.<InstanceIdentifier<?>>emptyList(),
-                        failedOnRevertException);
-        doThrow(revertFailedException).when(reverter).revert();
-
-        // Prepare modification:
-        final DataTreeCandidateNode rootNode = mockRootNode();
-        // data before:
-        final ContainerNode nodeBefore = mockContainerNode(dataBefore);
-        when(rootNode.getDataBefore()).thenReturn(Optional.<NormalizedNode<?, ?>>fromNullable(nodeBefore));
-        // data after:
-        final ContainerNode nodeAfter = mockContainerNode(dataAfter);
-        when(rootNode.getDataAfter()).thenReturn(Optional.<NormalizedNode<?, ?>>fromNullable(nodeAfter));
-
-        // Run the test
-        try {
-            proxy.commit(modification);
-        } catch (io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.RevertFailedException e) {
-            verify(vppWriter).update(anyMap(), anyMap(), any(WriteContext.class));
-            verify(reverter).revert();
-            assertEquals(failedOnRevertException, e.getCause());
-            return;
-        }
-
-        fail("RevertFailedException was expected");
-    }
-
-    private DataTreeCandidateNode mockRootNode() {
-        final DataTreeCandidate candidate = mock(DataTreeCandidate.class);
-        when(dataTree.prepare(modification)).thenReturn(candidate);
-
-        final DataTreeCandidateNode rootNode = mock(DataTreeCandidateNode.class);
-        when(candidate.getRootNode()).thenReturn(rootNode);
-
-        return rootNode;
-    }
-
-    private ContainerNode mockContainerNode(DataObject... modifications) {
-        final int numberOfChildren = modifications.length;
-
-        final YangInstanceIdentifier.NodeIdentifier identifier =
-                YangInstanceIdentifier.NodeIdentifier.create(QName.create("/"));
-
-        final ContainerNode node = mock(ContainerNode.class);
-        when(node.getIdentifier()).thenReturn(identifier);
-
-        final List<DataContainerChild> list = new ArrayList<>(numberOfChildren);
-        doReturn(list).when(node).getValue();
-
-        for (DataObject modification : modifications) {
-            final DataContainerChild child = mock(DataContainerChild.class);
-            when(child.getIdentifier()).thenReturn(mock(YangInstanceIdentifier.PathArgument.class));
-            list.add(child);
-
-            final Map.Entry entry = mock(Map.Entry.class);
-            final Class<? extends DataObject> implementedInterface =
-                    (Class<? extends DataObject>) modification.getImplementedInterface();
-            final InstanceIdentifier<?> id = InstanceIdentifier.create(implementedInterface);
-
-            doReturn(id).when(entry).getKey();
-            doReturn(modification).when(entry).getValue();
-            doReturn(entry).when(serializer).fromNormalizedNode(any(YangInstanceIdentifier.class), eq(child));
-        }
-        return node;
-    }
-}
diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppDataBrokerInitializationProviderTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppDataBrokerInitializationProviderTest.java
index 51f57a252..770ca7068 100644
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppDataBrokerInitializationProviderTest.java
+++ b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppDataBrokerInitializationProviderTest.java
@@ -26,6 +26,8 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.MockitoAnnotations.initMocks;
 
 import com.google.common.util.concurrent.CheckedFuture;
+import io.fd.honeycomb.v3po.config.WriterRegistry;
+import io.fd.honeycomb.v3po.impl.VppDataBrokerInitializationProvider;
 import io.fd.honeycomb.v3po.translate.read.ReaderRegistry;
 import org.junit.Before;
 import org.junit.Test;
diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppDataBrokerTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppDataBrokerTest.java
deleted file mode 100644
index 2550f458b..000000000
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppDataBrokerTest.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * 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.honeycomb.v3po.impl.data;
-
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import java.util.Map;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-
-public class VppDataBrokerTest {
-
-    @Mock
-    private ReadableVppDataTree operationalData;
-    @Mock
-    private VppDataTree confiDataTree;
-    @Mock
-    private VppDataTreeSnapshot configSnapshot;
-    private VppDataBroker broker;
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-        when(confiDataTree.takeSnapshot()).thenReturn(configSnapshot);
-        broker = new VppDataBroker(operationalData, confiDataTree);
-    }
-
-    @Test
-    public void testNewReadWriteTransaction() {
-        final DOMDataReadWriteTransaction readWriteTx = broker.newReadWriteTransaction();
-        final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
-        readWriteTx.read(LogicalDatastoreType.CONFIGURATION, path);
-
-        // verify that read and write transactions use the same config snapshot
-        verify(configSnapshot).read(path);
-        verify(configSnapshot).newModification();
-    }
-
-    @Test
-    public void testNewWriteOnlyTransaction() {
-        final DOMDataWriteTransaction writeTx = broker.newWriteOnlyTransaction();
-
-        // verify that write transactions use config snapshot
-        verify(configSnapshot).newModification();
-    }
-
-    @Test
-    public void testNewReadOnlyTransaction() {
-        final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction();
-
-        final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
-        readTx.read(LogicalDatastoreType.CONFIGURATION, path);
-
-        // verify that read transactions use config snapshot
-        verify(configSnapshot).read(path);
-    }
-
-    @Test(expected = UnsupportedOperationException.class)
-    public void testRegisterDataChangeListener() {
-        final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
-        final DOMDataChangeListener listener = mock(DOMDataChangeListener.class);
-        broker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, path, listener,
-                AsyncDataBroker.DataChangeScope.BASE);
-    }
-
-    @Test(expected = UnsupportedOperationException.class)
-    public void testCreateTransactionChain() {
-        final TransactionChainListener listener = mock(TransactionChainListener.class);
-        broker.createTransactionChain(listener);
-    }
-
-    @Test
-    public void testGetSupportedExtensions() {
-        final Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> supportedExtensions =
-                broker.getSupportedExtensions();
-        assertTrue(supportedExtensions.isEmpty());
-    }
-
-
-}
\ No newline at end of file
diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppOperationalDataTreeTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppOperationalDataTreeTest.java
deleted file mode 100644
index 049c2a0c8..000000000
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppOperationalDataTreeTest.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * 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.honeycomb.v3po.impl.data;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.LinkedListMultimap;
-import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.CheckedFuture;
-import io.fd.honeycomb.v3po.translate.read.ReadContext;
-import io.fd.honeycomb.v3po.translate.read.ReaderRegistry;
-import java.util.Map;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppState;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-
-public class VppOperationalDataTreeTest {
-
-    @Mock
-    private BindingNormalizedNodeSerializer serializer;
-    @Mock
-    private ReaderRegistry reader;
-
-    private VppOperationalDataTree operationalData;
-
-    @Mock
-    private InstanceIdentifier<DataObject> id;
-    @Mock
-    private Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry;
-    @Mock
-    private SchemaContext globalContext;
-    @Mock
-    private DataSchemaNode schemaNode;
-    @Mock
-    private ReadContext readCtx;
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-        operationalData = new VppOperationalDataTree(serializer, globalContext, reader);
-        doReturn(schemaNode).when(globalContext).getDataChildByName(any(QName.class));
-    }
-
-    @Test
-    public void testReadNode() throws Exception {
-        final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class);
-        final YangInstanceIdentifier.PathArgument pArg = mock(YangInstanceIdentifier.PathArgument.class);
-        doReturn(pArg).when(yangId).getLastPathArgument();
-
-        doReturn(QName.create("namespace", "2012-12-12", "local")).when(pArg).getNodeType();
-        doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId);
-
-        final DataObject dataObject = mock(DataObject.class);
-        doReturn(Optional.of(dataObject)).when(reader).read(same(id), any(ReadContext.class));
-
-        when(serializer.toNormalizedNode(id, dataObject)).thenReturn(entry);
-        final DataContainerChild<?, ?> expectedValue = mock(DataContainerChild.class);
-        doReturn(expectedValue).when(entry).getValue();
-
-        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future = operationalData.read(yangId);
-
-        verify(serializer).fromYangInstanceIdentifier(yangId);
-        verify(reader).read(same(id), any(ReadContext.class));
-        final Optional<NormalizedNode<?, ?>> result = future.get();
-        assertTrue(result.isPresent());
-        assertEquals(expectedValue, result.get());
-    }
-
-    @Test
-    public void testReadNonExistingNode() throws Exception {
-        final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class);
-        doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId);
-        doReturn(Optional.absent()).when(reader).read(same(id), any(ReadContext.class));
-
-        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future = operationalData.read(yangId);
-
-        verify(serializer).fromYangInstanceIdentifier(yangId);
-        verify(reader).read(same(id), any(ReadContext.class));
-        final Optional<NormalizedNode<?, ?>> result = future.get();
-        assertFalse(result.isPresent());
-    }
-
-    @Test
-    public void testReadFailed() throws Exception{
-        doThrow(io.fd.honeycomb.v3po.translate.read.ReadFailedException.class).when(reader).readAll(any(ReadContext.class));
-
-        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
-                operationalData.read( YangInstanceIdentifier.EMPTY);
-
-        try {
-            future.checkedGet();
-        } catch (ReadFailedException e) {
-            assertTrue(e.getCause() instanceof io.fd.honeycomb.v3po.translate.read.ReadFailedException);
-            return;
-        }
-        fail("ReadFailedException was expected");
-    }
-
-    @Test
-    public void testReadRootWithOneNonListElement() throws Exception {
-        // Prepare data
-        final InstanceIdentifier<VppState> vppStateII = InstanceIdentifier.create(VppState.class);
-        final VppState vppState = mock(VppState.class);
-        Multimap<InstanceIdentifier<?>, DataObject> dataObjects = LinkedListMultimap.create();
-        dataObjects.put(vppStateII, vppState);
-        doReturn(dataObjects).when(reader).readAll(any(ReadContext.class));
-
-        // Init serializer
-        final YangInstanceIdentifier vppYangId = YangInstanceIdentifier.builder().node(VppState.QNAME).build();
-        when(serializer.toYangInstanceIdentifier(vppStateII)).thenReturn(vppYangId);
-        when(serializer.toNormalizedNode(vppStateII, vppState)).thenReturn(entry);
-        final DataContainerChild<?, ?> vppStateContainer = mock(DataContainerChild.class);
-        doReturn(vppStateContainer).when(entry).getValue();
-        doReturn(vppYangId.getLastPathArgument()).when(vppStateContainer).getIdentifier();
-
-        // Read root
-        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
-                operationalData.read(YangInstanceIdentifier.EMPTY);
-
-        verify(reader).readAll(any(ReadContext.class));
-        verify(serializer).toYangInstanceIdentifier(vppStateII);
-        verify(serializer).toNormalizedNode(vppStateII, vppState);
-
-        // Check the result is an ContainerNode with only one child
-        final Optional<NormalizedNode<?, ?>> result = future.get();
-        assertTrue(result.isPresent());
-
-        final ContainerNode rootNode = (ContainerNode) result.get();
-        assertEquals(SchemaContext.NAME, rootNode.getIdentifier().getNodeType());
-        assertEquals(vppStateContainer, Iterables.getOnlyElement(rootNode.getValue()));
-    }
-}
\ No newline at end of file
diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppReadOnlyTransactionTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppReadOnlyTransactionTest.java
deleted file mode 100644
index 5a8a1f72b..000000000
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppReadOnlyTransactionTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * 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.honeycomb.v3po.impl.data;
-
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-
-public class VppReadOnlyTransactionTest {
-
-    @Mock
-    private ReadableVppDataTree operationalData;
-    @Mock
-    private VppDataTreeSnapshot configSnapshot;
-
-    private VppReadOnlyTransaction readOnlyTx;
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-        readOnlyTx = new VppReadOnlyTransaction(operationalData, configSnapshot);
-    }
-
-    @Test
-    public void testExists() {
-        final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
-        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException>
-                future = mock(CheckedFuture.class);
-        when(operationalData.read(path)).thenReturn(future);
-
-        readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, path);
-
-        verify(operationalData).read(path);
-    }
-
-    @Test
-    public void testGetIdentifier() {
-        assertNotNull(readOnlyTx.getIdentifier());
-    }
-}
\ No newline at end of file
diff --git a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppWriteTransactionTest.java b/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppWriteTransactionTest.java
deleted file mode 100644
index 905224216..000000000
--- a/v3po/impl/src/test/java/io/fd/honeycomb/v3po/impl/data/VppWriteTransactionTest.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * 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.honeycomb.v3po.impl.data;
-
-import static junit.framework.TestCase.assertTrue;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
-import com.google.common.util.concurrent.CheckedFuture;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
-
-public class VppWriteTransactionTest {
-
-    @Mock
-    private VppDataTree configDataTree;
-    @Mock
-    private VppDataTreeSnapshot configSnapshot;
-    @Mock
-    private YangInstanceIdentifier path;
-    @Mock
-    private NormalizedNode<?,?> data;
-    @Mock
-    private DataTreeModification dataTreeModification;
-
-    private VppWriteTransaction writeTx;
-
-    @Before
-    public void setUp() {
-        initMocks(this);
-        when(configSnapshot.newModification()).thenReturn(dataTreeModification);
-        writeTx = new VppWriteTransaction(configDataTree, configSnapshot);
-    }
-
-    @Test
-    public void testPut() {
-        writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data);
-        verify(dataTreeModification).write(path, data);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testPutOperational() {
-        writeTx.put(LogicalDatastoreType.OPERATIONAL, path, data);
-        verify(dataTreeModification).write(path, data);
-    }
-
-    @Test(expected = IllegalStateException.class)
-    public void testOnFinishedTx() {
-        writeTx.submit();
-        writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data);
-        verify(dataTreeModification).write(path, data);
-    }
-
-    @Test
-    public void testMerge() {
-        writeTx.merge(LogicalDatastoreType.CONFIGURATION, path, data);
-        verify(dataTreeModification).merge(path, data);
-    }
-
-    @Test
-    public void testCancel() {
-        assertTrue(writeTx.cancel());
-    }
-
-    @Test
-    public void testCancelFinished() {
-        writeTx.submit();
-        assertFalse(writeTx.cancel());
-    }
-
-    @Test
-    public void testDelete() {
-        writeTx.delete(LogicalDatastoreType.CONFIGURATION, path);
-        verify(dataTreeModification).delete(path);
-    }
-
-    @Test
-    public void testSubmit() throws Exception {
-        writeTx.submit();
-        verify(dataTreeModification).ready();
-        verify(configDataTree).commit(dataTreeModification);
-    }
-
-    @Test
-    public void testSubmitFailed() throws Exception {
-        doThrow(mock(DataValidationFailedException.class)).when(configDataTree).commit(dataTreeModification);
-        final CheckedFuture<Void, TransactionCommitFailedException> future = writeTx.submit();
-        try {
-            future.get();
-        } catch (Exception e) {
-            assertTrue(e.getCause() instanceof TransactionCommitFailedException);
-            return;
-        }
-        fail("Expected exception to be thrown");
-
-    }
-
-    @Test(expected = UnsupportedOperationException.class)
-    public void testCommit() {
-        writeTx.commit();
-    }
-
-    @Test
-    public void testGetIdentifier() {
-        assertNotNull(writeTx.getIdentifier());
-    }
-}
\ No newline at end of file