Add another alternative SchemaContextUtil.findDataSchemaNode()

[yangtools.git] / yang / yang-model-util / src / test / java / org / opendaylight / yangtools / yang / model / util / DataNodeIteratorTest.java

diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java
index 799dd63463f519444c5b4ad7caf4ea278221d719..41eb9b233d42a67f20bddb5208509efbf015167a 100644 (file)
--- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java
+++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java
@@ -21,26 +21,49 @@ import java.util.Set;
 import java.util.SortedMap;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.CopyableNode;
 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.Module;
 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
 
+@RunWith(MockitoJUnitRunner.class)
 public class DataNodeIteratorTest {
-
     private DataNodeIterator dataNodeIterator;
 
     @Before
-    public void setUp() {
-        DataNodeContainer dataNodeContainer = mock(DataNodeContainer.class);
-        this.dataNodeIterator = new DataNodeIterator(dataNodeContainer);
+    public void before() {
+        this.dataNodeIterator = new DataNodeIterator(mockDataNodeContainer(DataNodeContainer.class));
+    }
+
+    private static <T extends DataNodeContainer> T mockDataNodeContainer(final Class<T> clazz) {
+        final T mock = mock(clazz);
+        doReturn(Collections.emptyList()).when(mock).getChildNodes();
+        doReturn(Collections.emptySet()).when(mock).getGroupings();
+        doReturn(Collections.emptySet()).when(mock).getTypeDefinitions();
+        return mock;
+    }
+
+    private static <T extends OperationDefinition> T mockOperationDefinition(final T mock) {
+        doReturn(Collections.emptySet()).when(mock).getTypeDefinitions();
+        doReturn(mockDataNodeContainer(ContainerSchemaNode.class)).when(mock).getOutput();
+        return mock;
+    }
+
+    @Deprecated
+    private static <T extends CopyableNode> T mockCopyableNode(final boolean augmenting, final T node) {
+        doReturn(augmenting).when(node).isAugmenting();
+        return node;
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -61,28 +84,27 @@ public class DataNodeIteratorTest {
     @Test
     public void createDataNodeIteratorWith() {
         assertFalse("Has no next", dataNodeIterator.hasNext());
-        assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allChoices());
-        assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allContainers());
-        assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allTypedefs());
-        assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allGroupings());
-        assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allLists());
+        assertEquals("Should be empty list", Collections.emptyList(), dataNodeIterator.allChoices());
+        assertEquals("Should be empty list", Collections.emptyList(), dataNodeIterator.allContainers());
+        assertEquals("Should be empty list", Collections.emptyList(), dataNodeIterator.allTypedefs());
+        assertEquals("Should be empty list", Collections.emptyList(), dataNodeIterator.allGroupings());
+        assertEquals("Should be empty list", Collections.emptyList(), dataNodeIterator.allLists());
     }
 
     @Test
     public void testTraversal() {
-        final Module mockedModule = mock(Module.class);
-
-        final ContainerSchemaNode mockedAugmentingContainer = mock(ContainerSchemaNode.class);
-        doReturn(true).when(mockedAugmentingContainer).isAugmenting();
+        final Module mockedModule = mockDataNodeContainer(Module.class);
 
-        final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
+        final ContainerSchemaNode mockedAugmentingContainer = mockCopyableNode(true, mock(ContainerSchemaNode.class));
+        final ContainerSchemaNode mockedContainer = mockCopyableNode(false, mockDataNodeContainer(
+            ContainerSchemaNode.class));
 
-        final ListSchemaNode mockedList = mock(ListSchemaNode.class);
+        final ListSchemaNode mockedList = mockCopyableNode(false, mockDataNodeContainer(ListSchemaNode.class));
 
-        final ChoiceSchemaNode mockedChoice = mock(ChoiceSchemaNode.class);
-        final CaseSchemaNode mockedCase1 = mock(CaseSchemaNode.class);
+        final ChoiceSchemaNode mockedChoice = mockCopyableNode(false, mock(ChoiceSchemaNode.class));
+        final CaseSchemaNode mockedCase1 = mockDataNodeContainer(CaseSchemaNode.class);
         final QName mockedCase1QName = QName.create("", "case1");
-        final CaseSchemaNode mockedCase2 = mock(CaseSchemaNode.class);
+        final CaseSchemaNode mockedCase2 = mockDataNodeContainer(CaseSchemaNode.class);
         final QName mockedCase2QName = QName.create("", "case2");
         final SortedMap<QName, CaseSchemaNode> cases = ImmutableSortedMap.of(mockedCase1QName, mockedCase1,
             mockedCase2QName, mockedCase2);
@@ -92,17 +114,19 @@ public class DataNodeIteratorTest {
                 mockedChoice);
         doReturn(childNodes).when(mockedModule).getChildNodes();
 
-        final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
-        final ContainerSchemaNode mockedContainerInNotification = mock(ContainerSchemaNode.class);
+        final NotificationDefinition mockedNotification = mockDataNodeContainer(NotificationDefinition.class);
+        final ContainerSchemaNode mockedContainerInNotification = mockCopyableNode(false,
+            mockDataNodeContainer(ContainerSchemaNode.class));
         final Set<DataSchemaNode> notificationChildNodes = ImmutableSet.of(mockedContainerInNotification);
         doReturn(notificationChildNodes).when(mockedNotification).getChildNodes();
         final Set<NotificationDefinition> notifications = ImmutableSet.of(mockedNotification);
 
         doReturn(notifications).when(mockedModule).getNotifications();
 
-        final RpcDefinition mockedRpc = mock(RpcDefinition.class);
-        final ContainerSchemaNode mockedContainerInRpcInput = mock(ContainerSchemaNode.class);
-        final ListSchemaNode mockedListInRpcInputContainer = mock(ListSchemaNode.class);
+        final RpcDefinition mockedRpc = mockOperationDefinition(mock(RpcDefinition.class));
+        final ContainerSchemaNode mockedContainerInRpcInput = mockDataNodeContainer(ContainerSchemaNode.class);
+        final ListSchemaNode mockedListInRpcInputContainer = mockCopyableNode(false,
+            mockDataNodeContainer(ListSchemaNode.class));
         final Set<DataSchemaNode> rpcInputChildNodes = ImmutableSet.of(mockedListInRpcInputContainer);
         doReturn(rpcInputChildNodes).when(mockedContainerInRpcInput).getChildNodes();
         doReturn(mockedContainerInRpcInput).when(mockedRpc).getInput();
@@ -110,7 +134,7 @@ public class DataNodeIteratorTest {
 
         doReturn(rpcs).when(mockedModule).getRpcs();
 
-        final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
+        final GroupingDefinition mockedGrouping = mockDataNodeContainer(GroupingDefinition.class);
         final Set<GroupingDefinition> groupings = ImmutableSet.of(mockedGrouping);
 
         doReturn(groupings).when(mockedModule).getGroupings();