From: Igor Foltin Date: Fri, 16 Sep 2016 17:30:10 +0000 (+0200) Subject: Increase unit test coverage for Yangtools X-Git-Tag: release/carbon~350 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=refs%2Fchanges%2F45%2F45745%2F2;p=yangtools.git Increase unit test coverage for Yangtools Added test for NormalizedNodes. Added test for DataTreeCandidates Added test for DataTreeConfiguration. Added test for NormalizedNodeDataTreeCandidateNode. Change-Id: I71773e12f5a4d12f38c034740e3622ba94089bbc Signed-off-by: Igor Foltin --- diff --git a/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java new file mode 100644 index 0000000000..1ed24c9e6a --- /dev/null +++ b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java @@ -0,0 +1,128 @@ +/* + * 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 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); + } +} diff --git a/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidatesTest.java b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidatesTest.java new file mode 100644 index 0000000000..a42b699475 --- /dev/null +++ b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidatesTest.java @@ -0,0 +1,195 @@ +/* + * 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 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")); + } + } +} diff --git a/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeConfigurationTest.java b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeConfigurationTest.java new file mode 100644 index 0000000000..b3688baadf --- /dev/null +++ b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeConfigurationTest.java @@ -0,0 +1,49 @@ +/* + * 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()); + } +} diff --git a/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/NormalizedNodeDataTreeCandidateNodeTest.java b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/NormalizedNodeDataTreeCandidateNodeTest.java new file mode 100644 index 0000000000..5f61ac8b5f --- /dev/null +++ b/yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/NormalizedNodeDataTreeCandidateNodeTest.java @@ -0,0 +1,67 @@ +/* + * 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 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> mockedChildNodes = Lists.newArrayList(mockedChildNormNode1, + mockedChildNormNode2, null); + doReturn(mockedChildNodes).when(mockedNormalizedNodeContainer).getValue(); + final Collection 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)); + } +}