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

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.model.util;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.mock;
  15
  16 import com.google.common.collect.ImmutableSet;
  17 import com.google.common.collect.ImmutableSortedMap;
  18 import java.util.Collections;
  19 import java.util.NoSuchElementException;
  20 import java.util.Set;
  21 import java.util.SortedMap;
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.junit.runner.RunWith;
  25 import org.mockito.runners.MockitoJUnitRunner;
  26 import org.opendaylight.yangtools.yang.common.QName;
  27 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
  28 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  29 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  30 import org.opendaylight.yangtools.yang.model.api.CopyableNode;
  31 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  32 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  33 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  35 import org.opendaylight.yangtools.yang.model.api.Module;
  36 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  37 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
  38 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  39
  40 @RunWith(MockitoJUnitRunner.class)
  41 public class DataNodeIteratorTest {
  42     private DataNodeIterator dataNodeIterator;
  43
  44     @Before
  45     public void before() {
  46         this.dataNodeIterator = new DataNodeIterator(mockDataNodeContainer(DataNodeContainer.class));
  47     }
  48
  49     private static <T extends DataNodeContainer> T mockDataNodeContainer(final Class<T> clazz) {
  50         final T mock = mock(clazz);
  51         doReturn(Collections.emptyList()).when(mock).getChildNodes();
  52         doReturn(Collections.emptySet()).when(mock).getGroupings();
  53         doReturn(Collections.emptySet()).when(mock).getTypeDefinitions();
  54         return mock;
  55     }
  56
  57     private static <T extends OperationDefinition> T mockOperationDefinition(final T mock) {
  58         doReturn(Collections.emptySet()).when(mock).getGroupings();
  59         doReturn(Collections.emptySet()).when(mock).getTypeDefinitions();
  60         doReturn(mockDataNodeContainer(ContainerSchemaNode.class)).when(mock).getInput();
  61         doReturn(mockDataNodeContainer(ContainerSchemaNode.class)).when(mock).getOutput();
  62         return mock;
  63     }
  64
  65     @Deprecated
  66     private static <T extends CopyableNode> T mockCopyableNode(final boolean augmenting, final T node) {
  67         doReturn(augmenting).when(node).isAugmenting();
  68         return node;
  69     }
  70
  71     @Test(expected = IllegalArgumentException.class)
  72     public void createDataNodeIteratorWithNullArgument() {
  73         new DataNodeIterator(null);
  74     }
  75
  76     @Test(expected = UnsupportedOperationException.class)
  77     public void removeFromEmptyDataNodeContainer() {
  78         dataNodeIterator.remove();
  79     }
  80
  81     @Test(expected = NoSuchElementException.class)
  82     public void tryNextOnEmptyDataContainer() {
  83         dataNodeIterator.next();
  84     }
  85
  86     @Test
  87     public void createDataNodeIteratorWith() {
  88         assertFalse("Has no next", dataNodeIterator.hasNext());
  89         assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allChoices());
  90         assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allContainers());
  91         assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allTypedefs());
  92         assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allGroupings());
  93         assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allLists());
  94     }
  95
  96     @Test
  97     public void testTraversal() {
  98         final Module mockedModule = mockDataNodeContainer(Module.class);
  99
 100         final ContainerSchemaNode mockedAugmentingContainer = mockCopyableNode(true, mock(ContainerSchemaNode.class));
 101         final ContainerSchemaNode mockedContainer = mockCopyableNode(false, mockDataNodeContainer(
 102             ContainerSchemaNode.class));
 103
 104         final ListSchemaNode mockedList = mockCopyableNode(false, mockDataNodeContainer(ListSchemaNode.class));
 105
 106         final ChoiceSchemaNode mockedChoice = mockCopyableNode(false, mock(ChoiceSchemaNode.class));
 107         final CaseSchemaNode mockedCase1 = mockDataNodeContainer(CaseSchemaNode.class);
 108         final QName mockedCase1QName = QName.create("", "case1");
 109         final CaseSchemaNode mockedCase2 = mockDataNodeContainer(CaseSchemaNode.class);
 110         final QName mockedCase2QName = QName.create("", "case2");
 111         final SortedMap<QName, CaseSchemaNode> cases = ImmutableSortedMap.of(mockedCase1QName, mockedCase1,
 112             mockedCase2QName, mockedCase2);
 113         doReturn(cases).when(mockedChoice).getCases();
 114
 115         final Set<DataSchemaNode> childNodes = ImmutableSet.of(mockedAugmentingContainer, mockedContainer, mockedList,
 116                 mockedChoice);
 117         doReturn(childNodes).when(mockedModule).getChildNodes();
 118
 119         final NotificationDefinition mockedNotification = mockDataNodeContainer(NotificationDefinition.class);
 120         final ContainerSchemaNode mockedContainerInNotification = mockCopyableNode(false,
 121             mockDataNodeContainer(ContainerSchemaNode.class));
 122         final Set<DataSchemaNode> notificationChildNodes = ImmutableSet.of(mockedContainerInNotification);
 123         doReturn(notificationChildNodes).when(mockedNotification).getChildNodes();
 124         final Set<NotificationDefinition> notifications = ImmutableSet.of(mockedNotification);
 125
 126         doReturn(notifications).when(mockedModule).getNotifications();
 127
 128         final RpcDefinition mockedRpc = mockOperationDefinition(mock(RpcDefinition.class));
 129         final ContainerSchemaNode mockedContainerInRpcInput = mockDataNodeContainer(ContainerSchemaNode.class);
 130         final ListSchemaNode mockedListInRpcInputContainer = mockCopyableNode(false,
 131             mockDataNodeContainer(ListSchemaNode.class));
 132         final Set<DataSchemaNode> rpcInputChildNodes = ImmutableSet.of(mockedListInRpcInputContainer);
 133         doReturn(rpcInputChildNodes).when(mockedContainerInRpcInput).getChildNodes();
 134         doReturn(mockedContainerInRpcInput).when(mockedRpc).getInput();
 135         final Set<RpcDefinition> rpcs = ImmutableSet.of(mockedRpc);
 136
 137         doReturn(rpcs).when(mockedModule).getRpcs();
 138
 139         final GroupingDefinition mockedGrouping = mockDataNodeContainer(GroupingDefinition.class);
 140         final Set<GroupingDefinition> groupings = ImmutableSet.of(mockedGrouping);
 141
 142         doReturn(groupings).when(mockedModule).getGroupings();
 143
 144         final DataNodeIterator it = new DataNodeIterator(mockedModule);
 145         assertFalse(it.allContainers().contains(mockedAugmentingContainer));
 146         assertTrue(it.allContainers().contains(mockedContainer));
 147         assertTrue(it.allLists().contains(mockedList));
 148         assertTrue(it.allChoices().contains(mockedChoice));
 149         assertTrue(it.allChoices().get(0).getCases().values().contains(mockedCase1));
 150         assertTrue(it.allChoices().get(0).getCases().values().contains(mockedCase2));
 151         assertTrue(it.allContainers().contains(mockedContainerInNotification));
 152         assertTrue(it.allLists().contains(mockedListInRpcInputContainer));
 153         assertTrue(it.allGroupings().contains(mockedGrouping));
 154     }
 155 }