*/
package org.opendaylight.yangtools.yang.model.util;
-import org.junit.Before;
-import org.junit.Test;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-
-import java.util.Collections;
-import java.util.NoSuchElementException;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-public class DataNodeIteratorTest {
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedMap;
+import java.util.Collections;
+import java.util.NoSuchElementException;
+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)
+ @Test(expected = IllegalArgumentException.class)
public void createDataNodeIteratorWithNullArgument() {
new DataNodeIterator(null);
}
- @Test(expected=UnsupportedOperationException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void removeFromEmptyDataNodeContainer() {
dataNodeIterator.remove();
}
@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 = mockDataNodeContainer(Module.class);
+
+ final ContainerSchemaNode mockedAugmentingContainer = mockCopyableNode(true, mock(ContainerSchemaNode.class));
+ final ContainerSchemaNode mockedContainer = mockCopyableNode(false, mockDataNodeContainer(
+ ContainerSchemaNode.class));
+
+ final ListSchemaNode mockedList = mockCopyableNode(false, mockDataNodeContainer(ListSchemaNode.class));
+
+ final ChoiceSchemaNode mockedChoice = mockCopyableNode(false, mock(ChoiceSchemaNode.class));
+ final CaseSchemaNode mockedCase1 = mockDataNodeContainer(CaseSchemaNode.class);
+ final QName mockedCase1QName = QName.create("", "case1");
+ final CaseSchemaNode mockedCase2 = mockDataNodeContainer(CaseSchemaNode.class);
+ final QName mockedCase2QName = QName.create("", "case2");
+ final SortedMap<QName, CaseSchemaNode> cases = ImmutableSortedMap.of(mockedCase1QName, mockedCase1,
+ mockedCase2QName, mockedCase2);
+ doReturn(cases).when(mockedChoice).getCases();
+
+ final Set<DataSchemaNode> childNodes = ImmutableSet.of(mockedAugmentingContainer, mockedContainer, mockedList,
+ mockedChoice);
+ doReturn(childNodes).when(mockedModule).getChildNodes();
+
+ 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 = 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();
+ final Set<RpcDefinition> rpcs = ImmutableSet.of(mockedRpc);
+
+ doReturn(rpcs).when(mockedModule).getRpcs();
+
+ final GroupingDefinition mockedGrouping = mockDataNodeContainer(GroupingDefinition.class);
+ final Set<GroupingDefinition> groupings = ImmutableSet.of(mockedGrouping);
+
+ doReturn(groupings).when(mockedModule).getGroupings();
+
+ final DataNodeIterator it = new DataNodeIterator(mockedModule);
+ assertFalse(it.allContainers().contains(mockedAugmentingContainer));
+ assertTrue(it.allContainers().contains(mockedContainer));
+ assertTrue(it.allLists().contains(mockedList));
+ assertTrue(it.allChoices().contains(mockedChoice));
+ assertTrue(it.allChoices().get(0).getCases().values().contains(mockedCase1));
+ assertTrue(it.allChoices().get(0).getCases().values().contains(mockedCase2));
+ assertTrue(it.allContainers().contains(mockedContainerInNotification));
+ assertTrue(it.allLists().contains(mockedListInRpcInputContainer));
+ assertTrue(it.allGroupings().contains(mockedGrouping));
}
-}
\ No newline at end of file
+}
Code Review / yangtools.git / blobdiff