Added test for NormalizedNodes.
Added test for DataTreeCandidates
Added test for DataTreeConfiguration.
Added test for NormalizedNodeDataTreeCandidateNode.
Change-Id: I71773e12f5a4d12f38c034740e3622ba94089bbc
Signed-off-by: Igor Foltin <ifoltin@cisco.com>
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.yangtools.yang.data.api.schema;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+
+public class NormalizedNodesTest {
+
+ @Test
+ public void testGetDirectChild() {
+ final PathArgument mockedPathArgument = mock(PathArgument.class);
+
+ final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
+ assertEquals(Optional.absent(), NormalizedNodes.getDirectChild(mockedLeafNode, mockedPathArgument));
+
+ final LeafSetEntryNode<?> mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
+ assertEquals(Optional.absent(), NormalizedNodes.getDirectChild(mockedLeafSetEntryNode, mockedPathArgument));
+
+ final DataContainerNode<?> mockedDataContainerNode = mock(DataContainerNode.class);
+ final ContainerNode mockedContainerNode = mock(ContainerNode.class);
+ doReturn(Optional.of(mockedContainerNode)).when(mockedDataContainerNode).getChild(any(PathArgument.class));
+ assertEquals(mockedContainerNode, NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument).get());
+
+ final MapNode mockedMapNode = mock(MapNode.class);
+ final QName listQName = QName.create("test-ns", "test-list");
+ final QName listKeyQName = QName.create("test-ns", "test-list-key");
+ final NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
+ new NodeIdentifierWithPredicates(listQName, listKeyQName, "str-value");
+ final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
+ doReturn(Optional.of(mockedMapEntryNode)).when(mockedMapNode).getChild(any(NodeIdentifierWithPredicates.class));
+ assertEquals(mockedMapEntryNode, NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates).get());
+ assertEquals(Optional.absent(), NormalizedNodes.getDirectChild(mockedMapNode, mockedPathArgument));
+
+ final LeafSetNode<?> mockedLeafSetNode = mock(LeafSetNode.class);
+ final QName leafListQName = QName.create("test-ns", "test-leaf-list");
+ final NodeWithValue<?> nodeWithValue = new NodeWithValue<>(leafListQName, "str-value");
+ doReturn(Optional.of(mockedLeafSetEntryNode)).when(mockedLeafSetNode).getChild(any(NodeWithValue.class));
+ assertEquals(mockedLeafSetEntryNode, NormalizedNodes.getDirectChild(mockedLeafSetNode, nodeWithValue).get());
+ }
+
+ @Test
+ public void testFindNode() {
+ final DataContainerNode<?> mockedDataContainerNode = mock(DataContainerNode.class);
+ final ContainerNode mockedContainerNode = mock(ContainerNode.class);
+ final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
+ doReturn(Optional.of(mockedContainerNode)).when(mockedDataContainerNode).getChild(any(PathArgument.class));
+ doReturn(Optional.of(mockedLeafNode)).when(mockedContainerNode).getChild(any(PathArgument.class));
+
+ final QName node1QName = QName.create("test-ns", "2016-09-16", "node1");
+ final QName node2Qname = QName.create("test-ns", "2016-09-16", "node2");
+ final QName node3QName = QName.create("test-ns", "2016-09-16", "node3");
+ final QName node4Qname = QName.create("test-ns", "2016-09-16", "node4");
+
+ final YangInstanceIdentifier rootPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
+ new NodeIdentifier(node2Qname));
+ final YangInstanceIdentifier childPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
+ new NodeIdentifier(node2Qname), new NodeIdentifier(node3QName), new NodeIdentifier(node4Qname));
+
+ assertEquals(mockedLeafNode, NormalizedNodes.findNode(rootPath, mockedDataContainerNode, childPath).get());
+ assertEquals(Optional.absent(), NormalizedNodes.findNode(childPath, mockedDataContainerNode, rootPath));
+
+ final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
+ final PathArgument[] pathArguments = relativePath.get().getPathArguments().toArray(new PathArgument[2]);
+
+ assertEquals(mockedLeafNode, NormalizedNodes.findNode(Optional.of(mockedDataContainerNode),
+ pathArguments).get());
+
+ assertEquals(mockedLeafNode, NormalizedNodes.findNode(mockedDataContainerNode, pathArguments).get());
+ }
+
+ @Test
+ public void testToStringTree() {
+ final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
+ final QName leafNodeQName = QName.create("test-ns", "2016-09-16", "leaf-node");
+ final NodeIdentifier leafNodeId = new NodeIdentifier(leafNodeQName);
+ doReturn(leafNodeId).when(mockedLeafNode).getIdentifier();
+ doReturn("str-value-1").when(mockedLeafNode).getValue();
+
+ String stringTree = NormalizedNodes.toStringTree(mockedLeafNode);
+ assertNotNull(stringTree);
+ assertEquals("leaf-node str-value-1\n", stringTree);
+
+ final AugmentationNode mockedAugmentationNode = mock(AugmentationNode.class);
+ final QName listQName = QName.create("test-ns", "2016-09-16", "list-node");
+ final AugmentationIdentifier augNodeId = new AugmentationIdentifier(Sets.newHashSet(listQName));
+ doReturn(augNodeId).when(mockedAugmentationNode).getIdentifier();
+
+ final MapNode mockedMapNode = mock(MapNode.class);
+ final NodeIdentifier listNodeId = new NodeIdentifier(listQName);
+ doReturn(listNodeId).when(mockedMapNode).getIdentifier();
+ doReturn(Lists.newArrayList(mockedMapNode)).when(mockedAugmentationNode).getValue();
+
+ final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
+ final NodeIdentifierWithPredicates listEntryNodeId = new NodeIdentifierWithPredicates(listQName,
+ leafNodeQName, "key-leaf-value");
+ doReturn(listEntryNodeId).when(mockedMapEntryNode).getIdentifier();
+ doReturn(Lists.newArrayList(mockedMapEntryNode)).when(mockedMapNode).getValue();
+
+ doReturn(Lists.newArrayList(mockedLeafNode)).when(mockedMapEntryNode).getValue();
+
+ stringTree = NormalizedNodes.toStringTree(mockedAugmentationNode);
+ assertNotNull(stringTree);
+ assertEquals("augmentation {\n list-node {\n list-node[key-leaf-value] {\n leaf-node " +
+ "str-value-1\n }\n }\n}\n", stringTree);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.yangtools.yang.data.api.schema.tree;
+
+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.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+import java.util.Collection;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+public class DataTreeCandidatesTest {
+
+ @Test
+ public void testNewDataTreeCandidate() {
+ final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
+ final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+ final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.newDataTreeCandidate(mockedRootPath,
+ mockedDataTreeCandidateNode);
+
+ assertNotNull(dataTreeCandidate);
+ assertTrue(dataTreeCandidate instanceof DefaultDataTreeCandidate);
+ assertEquals(mockedRootPath, dataTreeCandidate.getRootPath());
+ assertEquals(mockedDataTreeCandidateNode, dataTreeCandidate.getRootNode());
+ assertTrue(dataTreeCandidate.toString().contains(
+ "DefaultDataTreeCandidate{rootPath=/, rootNode=Mock for DataTreeCandidateNode, hashCode: "));
+ }
+
+ @Test
+ public void testFromNormalizedNode() {
+ final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
+ final NormalizedNode<?, ?> mockedNormalizedNode = mock(NormalizedNode.class);
+ final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.fromNormalizedNode(mockedRootPath,
+ mockedNormalizedNode);
+
+ assertNotNull(dataTreeCandidate);
+ assertTrue(dataTreeCandidate instanceof DefaultDataTreeCandidate);
+ assertEquals(mockedRootPath, dataTreeCandidate.getRootPath());
+ assertTrue(dataTreeCandidate.getRootNode() instanceof NormalizedNodeDataTreeCandidateNode);
+ }
+
+ @Test
+ public void testApplyToCursor() {
+ final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+ final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+
+ final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+ doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
+ doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
+ DataTreeCandidates.applyToCursor(mockedCursor, mockedDataTreeCandidate);
+ verify(mockedCursor, times(1)).delete(any(PathArgument.class));
+ }
+
+ @Test
+ public void testApplyToCursorAwareModification() {
+ final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+ final CursorAwareDataTreeModification mockedModification = mock(CursorAwareDataTreeModification.class);
+
+ final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
+ doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
+ final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
+ doReturn(mockedCursor).when(mockedModification).createCursor(any(YangInstanceIdentifier.class));
+ final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+ doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
+
+ doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
+
+ DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
+ verify(mockedModification, times(1)).createCursor(any(YangInstanceIdentifier.class));
+ verify(mockedCursor, times(1)).delete(any(PathArgument.class));
+
+ doReturn(true).when(mockedRootPath).isEmpty();
+ try {
+ DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
+ fail("An IllegalArgumentException should have been thrown!");
+ } catch (IllegalArgumentException ex) {
+ assertTrue(ex.getMessage().contains("Can not delete root"));
+ }
+ }
+
+ @Test
+ public void testApplyToModificationWithDeleteModificationType() {
+ final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+ final DataTreeModification mockedModification = mock(DataTreeModification.class);
+
+ final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+ doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
+ final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
+ doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
+
+ doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
+
+ DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
+ verify(mockedModification, times(1)).delete(any(YangInstanceIdentifier.class));
+ }
+
+ @Test
+ public void testApplyToModificationWithWriteModificationType() {
+ final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+ final DataTreeModification mockedModification = mock(DataTreeModification.class);
+
+ final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+ doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
+ final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
+ doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
+ final NormalizedNode<?, ?> mockedNormalizedNode = mock(NormalizedNode.class);
+ doReturn(Optional.of(mockedNormalizedNode)).when(mockedDataTreeCandidateNode).getDataAfter();
+
+ doReturn(ModificationType.WRITE).when(mockedDataTreeCandidateNode).getModificationType();
+
+ DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
+ verify(mockedModification, times(1)).write(any(YangInstanceIdentifier.class), any(NormalizedNode.class));
+ }
+
+ @Test
+ public void testApplyToModificationWithSubtreeModifiedModificationType() {
+ final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+ final DataTreeModification mockedModification = mock(DataTreeModification.class);
+
+ final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+ doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
+ final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
+ doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
+
+ doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedDataTreeCandidateNode).getModificationType();
+
+ final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
+ doReturn(ModificationType.DELETE).when(mockedChildNode1).getModificationType();
+ final PathArgument mockedPathArgument1 = mock(PathArgument.class);
+ doReturn(mockedPathArgument1).when(mockedChildNode1).getIdentifier();
+
+ final DataTreeCandidateNode mockedChildNode2 = mock(DataTreeCandidateNode.class);
+ doReturn(ModificationType.WRITE).when(mockedChildNode2).getModificationType();
+ final NormalizedNode<?, ?> mockedNormalizedNode = mock(NormalizedNode.class);
+ doReturn(Optional.of(mockedNormalizedNode)).when(mockedChildNode2).getDataAfter();
+ final PathArgument mockedPathArgument2 = mock(PathArgument.class);
+ doReturn(mockedPathArgument2).when(mockedChildNode2).getIdentifier();
+
+ final DataTreeCandidateNode mockedChildNode3 = mock(DataTreeCandidateNode.class);
+ doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedChildNode3).getModificationType();
+ final PathArgument mockedPathArgument3 = mock(PathArgument.class);
+ doReturn(mockedPathArgument3).when(mockedChildNode3).getIdentifier();
+ final DataTreeCandidateNode mockedChildNode3ChildNode = mock(DataTreeCandidateNode.class);
+ doReturn(ModificationType.DELETE).when(mockedChildNode3ChildNode).getModificationType();
+ final PathArgument mockedPathArgument31 = mock(PathArgument.class);
+ doReturn(mockedPathArgument3).when(mockedChildNode3).getIdentifier();
+ doReturn(mockedPathArgument31).when(mockedChildNode3ChildNode).getIdentifier();
+ doReturn(Lists.newArrayList(mockedChildNode3ChildNode)).when(mockedChildNode3).getChildNodes();
+
+ final Collection<DataTreeCandidateNode> childNodes = Lists.newArrayList(mockedChildNode1, mockedChildNode2,
+ mockedChildNode3);
+ doReturn(childNodes).when(mockedDataTreeCandidateNode).getChildNodes();
+
+ DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
+ verify(mockedModification, times(2)).delete(any(YangInstanceIdentifier.class));
+ verify(mockedModification, times(1)).write(any(YangInstanceIdentifier.class), any(NormalizedNode.class));
+ }
+
+ @Test
+ public void testApplyToModificationWithUnsupportedModificationType() {
+ final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
+ final DataTreeModification mockedModification = mock(DataTreeModification.class);
+
+ final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
+ doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
+ final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
+ doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
+
+ doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).getModificationType();
+
+ try {
+ DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
+ fail("An IllegalArgumentException should have been thrown!");
+ } catch (IllegalArgumentException ex) {
+ assertTrue(ex.getMessage().contains("Unsupported modification"));
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.yangtools.yang.data.api.schema.tree;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class DataTreeConfigurationTest {
+
+ @Test
+ public void testDataTreeConfiguration() {
+ DataTreeConfiguration.Builder builder = new DataTreeConfiguration.Builder(TreeType.CONFIGURATION);
+ builder.setUniqueIndexes(true);
+ builder.setMandatoryNodesValidation(true);
+
+ DataTreeConfiguration dataTreeConfiguration = builder.build();
+ assertEquals(TreeType.CONFIGURATION, dataTreeConfiguration.getTreeType());
+ assertTrue(dataTreeConfiguration.isUniqueIndexEnabled());
+ assertTrue(dataTreeConfiguration.isMandatoryNodesValidationEnabled());
+
+ builder = new DataTreeConfiguration.Builder(TreeType.OPERATIONAL);
+ builder.setUniqueIndexes(false);
+ builder.setMandatoryNodesValidation(false);
+
+ dataTreeConfiguration = builder.build();
+ assertEquals(TreeType.OPERATIONAL, dataTreeConfiguration.getTreeType());
+ assertFalse(dataTreeConfiguration.isUniqueIndexEnabled());
+ assertFalse(dataTreeConfiguration.isMandatoryNodesValidationEnabled());
+
+ dataTreeConfiguration = DataTreeConfiguration.getDefault(TreeType.CONFIGURATION);
+ assertEquals(TreeType.CONFIGURATION, dataTreeConfiguration.getTreeType());
+ assertFalse(dataTreeConfiguration.isUniqueIndexEnabled());
+ assertTrue(dataTreeConfiguration.isMandatoryNodesValidationEnabled());
+
+ dataTreeConfiguration = DataTreeConfiguration.getDefault(TreeType.OPERATIONAL);
+ assertEquals(TreeType.OPERATIONAL, dataTreeConfiguration.getTreeType());
+ assertFalse(dataTreeConfiguration.isUniqueIndexEnabled());
+ assertTrue(dataTreeConfiguration.isMandatoryNodesValidationEnabled());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.yangtools.yang.data.api.schema.tree;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+import java.util.Collection;
+import java.util.List;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
+
+public class NormalizedNodeDataTreeCandidateNodeTest {
+
+ @Test
+ public void testNormalizedNodeDataTreeCandidateNode() {
+ final NormalizedNode<?, ?> mockedNormalizedNode = mock(NormalizedNode.class);
+ final NormalizedNodeDataTreeCandidateNode normalizedNodeDataTreeCandidateNode = new
+ NormalizedNodeDataTreeCandidateNode(mockedNormalizedNode);
+
+ final PathArgument mockedPathArgument = mock(PathArgument.class);
+ doReturn(mockedPathArgument).when(mockedNormalizedNode).getIdentifier();
+ assertEquals(mockedPathArgument, normalizedNodeDataTreeCandidateNode.getIdentifier());
+
+ final Collection<DataTreeCandidateNode> childNodes = normalizedNodeDataTreeCandidateNode.getChildNodes();
+ assertTrue(childNodes instanceof List);
+ assertTrue(childNodes.isEmpty());
+
+ assertNull(normalizedNodeDataTreeCandidateNode.getModifiedChild(mockedPathArgument));
+
+ assertEquals(ModificationType.WRITE, normalizedNodeDataTreeCandidateNode.getModificationType());
+ assertEquals(Optional.of(mockedNormalizedNode), normalizedNodeDataTreeCandidateNode.getDataAfter());
+ assertEquals(Optional.absent(), normalizedNodeDataTreeCandidateNode.getDataBefore());
+
+ final NormalizedNodeContainer mockedNormalizedNodeContainer = mock(NormalizedNodeContainer.class);
+ final NormalizedNodeDataTreeCandidateNode normalizedNodeDataTreeCandidateNode2 = new
+ NormalizedNodeDataTreeCandidateNode(mockedNormalizedNodeContainer);
+ final NormalizedNode<?, ?> mockedChildNormNode1 = mock(NormalizedNode.class);
+ final NormalizedNode<?, ?> mockedChildNormNode2 = mock(NormalizedNode.class);
+ final Collection<NormalizedNode<?, ?>> mockedChildNodes = Lists.newArrayList(mockedChildNormNode1,
+ mockedChildNormNode2, null);
+ doReturn(mockedChildNodes).when(mockedNormalizedNodeContainer).getValue();
+ final Collection<DataTreeCandidateNode> childNodes2 = normalizedNodeDataTreeCandidateNode2.getChildNodes();
+ assertEquals(3, childNodes2.size());
+
+ doReturn(Optional.absent()).when(mockedNormalizedNodeContainer).getChild(any(PathArgument.class));
+ assertNull(normalizedNodeDataTreeCandidateNode2.getModifiedChild(mockedPathArgument));
+
+ doReturn(Optional.of(mockedChildNormNode1)).when(mockedNormalizedNodeContainer).getChild(any(PathArgument.class));
+ assertNotNull(normalizedNodeDataTreeCandidateNode2.getModifiedChild(mockedPathArgument));
+ }
+}
Code Review / yangtools.git / commitdiff