2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.yangtools.yang.data.impl.schema;
10 import static org.hamcrest.MatcherAssert.assertThat;
11 import static org.hamcrest.Matchers.isA;
12 import static org.junit.Assert.assertArrayEquals;
13 import static org.junit.Assert.assertEquals;
15 import com.google.common.collect.ImmutableMap;
16 import com.google.common.collect.ImmutableSet;
17 import java.util.Collection;
19 import org.junit.AfterClass;
20 import org.junit.BeforeClass;
21 import org.junit.Test;
22 import org.opendaylight.yangtools.util.ImmutableOffsetMap;
23 import org.opendaylight.yangtools.yang.common.QName;
24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
29 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
30 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
31 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
34 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
35 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
37 public class InstanceIdToNodesTest {
39 private static final String NS = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:normalization:test";
40 private static final String REVISION = "2014-03-13";
41 private static final QName ID = QName.create(NS, REVISION, "id");
42 private static final QName FOO = QName.create(ID, "foo");
43 private static final QName BAR = QName.create(ID, "bar");
44 private static final NodeIdentifier TWO_KEY_LIST = NodeIdentifier.create(QName.create(ID, "two-key-list"));
46 private static SchemaContext ctx;
48 private final NodeIdentifier rootContainer = new NodeIdentifier(QName.create(NS, REVISION, "test"));
49 private final NodeIdentifier outerContainer = new NodeIdentifier(QName.create(NS, REVISION, "outer-container"));
50 private final NodeIdentifier augmentedLeaf = new NodeIdentifier(QName.create(NS, REVISION, "augmented-leaf"));
51 private final AugmentationIdentifier augmentation = new AugmentationIdentifier(
52 ImmutableSet.of(augmentedLeaf.getNodeType()));
54 private final NodeIdentifier outerList = new NodeIdentifier(QName.create(NS, REVISION, "outer-list"));
55 private final NodeIdentifierWithPredicates outerListWithKey = NodeIdentifierWithPredicates.of(
56 QName.create(NS, REVISION, "outer-list"), ID, 1);
57 private final NodeIdentifier choice = new NodeIdentifier(QName.create(NS, REVISION, "outer-choice"));
58 private final NodeIdentifier leafFromCase = new NodeIdentifier(QName.create(NS, REVISION, "one"));
60 private final NodeIdentifier leafList = new NodeIdentifier(QName.create(NS, REVISION, "ordered-leaf-list"));
61 private final NodeWithValue<?> leafListWithValue = new NodeWithValue<>(leafList.getNodeType(), "abcd");
64 public static void setUp() {
65 ctx = YangParserTestUtils.parseYangResources(InstanceIdToNodesTest.class, "/filter-test.yang");
69 public static void teardown() {
74 public void testInAugment() {
75 final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf).withValue("").build();
76 final ContainerNode expectedFilter = Builders
78 .withNodeIdentifier(rootContainer)
80 Builders.containerBuilder()
81 .withNodeIdentifier(outerContainer)
83 Builders.augmentationBuilder()
84 .withNodeIdentifier(augmentation)
86 leaf).build()).build()).build();
88 final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
89 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), leaf);
90 assertEquals(expectedFilter, filter);
94 public void testInAugmentLeafOverride() {
95 final LeafNode<Object> lastLeaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
96 .withValue("randomValue").build();
98 final ContainerNode expectedFilter = Builders
100 .withNodeIdentifier(rootContainer)
102 Builders.containerBuilder()
103 .withNodeIdentifier(outerContainer)
105 Builders.augmentationBuilder().withNodeIdentifier(augmentation)
106 .withChild(lastLeaf).build()).build()).build();
108 final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
109 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), lastLeaf);
110 assertEquals(expectedFilter, filter);
114 public void testListChoice() {
115 final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(leafFromCase).withValue("").build();
116 final ContainerNode expectedFilter = Builders
118 .withNodeIdentifier(rootContainer)
120 Builders.mapBuilder()
121 .withNodeIdentifier(outerList)
123 Builders.mapEntryBuilder()
124 .withNodeIdentifier(outerListWithKey)
126 Builders.leafBuilder()
128 new NodeIdentifier(ID))
129 .withValue(1).build())
131 Builders.choiceBuilder()
132 .withNodeIdentifier(choice)
139 final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
140 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase), leaf);
141 assertEquals(expectedFilter, filter);
145 public void testTopContainerLastChildOverride() {
146 final ContainerNode expectedStructure = Builders
148 .withNodeIdentifier(rootContainer)
150 Builders.mapBuilder()
151 .withNodeIdentifier(outerList)
153 Builders.mapEntryBuilder()
154 .withNodeIdentifier(outerListWithKey)
156 Builders.leafBuilder()
158 new NodeIdentifier(ID))
159 .withValue(1).build())
161 Builders.choiceBuilder()
162 .withNodeIdentifier(choice)
164 Builders.leafBuilder()
165 .withNodeIdentifier(leafFromCase)
167 .build()).build()).build()).build())
170 final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
171 YangInstanceIdentifier.create(rootContainer), expectedStructure);
172 assertEquals(expectedStructure, filter);
176 public void testListLastChildOverride() {
177 final MapEntryNode outerListEntry = Builders
179 .withNodeIdentifier(outerListWithKey)
181 Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(ID))
182 .withValue(1).build()).build();
183 final MapNode lastChild = Builders.mapBuilder().withNodeIdentifier(this.outerList).withChild(outerListEntry)
185 final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer)
186 .withChild(lastChild).build();
188 NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
189 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey), outerListEntry);
190 assertEquals(expectedStructure, filter);
191 filter = ImmutableNodes.fromInstanceId(ctx,
192 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
193 assertEquals(expectedStructure, filter);
197 public void testLeafList() {
198 final ContainerNode expectedFilter = Builders
200 .withNodeIdentifier(rootContainer)
202 Builders.orderedLeafSetBuilder()
203 .withNodeIdentifier(leafList)
205 Builders.leafSetEntryBuilder().withNodeIdentifier(leafListWithValue)
206 .withValue(leafListWithValue.getValue()).build()).build()).build();
208 final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
209 YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue));
210 assertEquals(expectedFilter, filter);
214 public void testEmptyInstanceIdentifier() {
215 assertEquals(ImmutableNodes.containerNode(SchemaContext.NAME),
216 ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.empty()));
220 public void testKeyOrdering() {
221 final Map<QName, Object> misordered = ImmutableOffsetMap.orderedCopyOf(ImmutableMap.of(BAR, "bar", FOO, "foo"));
222 final NodeIdentifierWithPredicates id = NodeIdentifierWithPredicates.of(TWO_KEY_LIST.getNodeType(), misordered);
223 assertArrayEquals(new Object[] { BAR, FOO }, id.keySet().toArray());
225 final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
226 YangInstanceIdentifier.create(TWO_KEY_LIST, id));
227 assertThat(filter, isA(MapNode.class));
228 final Collection<MapEntryNode> value = ((MapNode) filter).body();
229 assertEquals(1, value.size());
230 final MapEntryNode entry = value.iterator().next();
232 // The entry must have a the proper order
233 assertArrayEquals(new Object[] { FOO, BAR }, entry.getIdentifier().keySet().toArray());