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.junit.Assert.assertEquals;
12 import java.util.Collections;
13 import org.junit.AfterClass;
14 import org.junit.BeforeClass;
15 import org.junit.Test;
16 import org.opendaylight.yangtools.yang.common.QName;
17 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
18 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
22 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
23 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
24 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
25 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
26 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
27 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
28 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
30 public class InstanceIdToNodesTest {
32 private static final String NS = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:normalization:test";
33 private static final String REVISION = "2014-03-13";
34 private static final QName ID = QName.create(NS, REVISION, "id");
35 private static SchemaContext ctx;
37 private final NodeIdentifier rootContainer = new NodeIdentifier(QName.create(NS, REVISION, "test"));
38 private final NodeIdentifier outerContainer = new NodeIdentifier(QName.create(NS, REVISION, "outer-container"));
39 private final NodeIdentifier augmentedLeaf = new NodeIdentifier(QName.create(NS, REVISION, "augmented-leaf"));
40 private final AugmentationIdentifier augmentation = new AugmentationIdentifier(
41 Collections.singleton(augmentedLeaf.getNodeType()));
43 private final NodeIdentifier outerList = new NodeIdentifier(
44 QName.create(NS, REVISION, "outer-list"));
45 private final NodeIdentifierWithPredicates outerListWithKey = new NodeIdentifierWithPredicates(
46 QName.create(NS, REVISION, "outer-list"), ID, 1);
47 private final NodeIdentifier choice = new NodeIdentifier(QName.create(NS, REVISION, "outer-choice"));
48 private final NodeIdentifier leafFromCase = new NodeIdentifier(QName.create(NS, REVISION, "one"));
50 private final NodeIdentifier leafList = new NodeIdentifier(QName.create(NS, REVISION, "ordered-leaf-list"));
51 private final NodeWithValue<?> leafListWithValue = new NodeWithValue<>(
52 leafList.getNodeType(), "abcd");
55 public static void setUp() {
56 ctx = YangParserTestUtils.parseYangResources(InstanceIdToNodesTest.class, "/filter-test.yang");
60 public static void teardown() {
65 public void testInAugment() {
66 final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf).withValue("").build();
67 final ContainerNode expectedFilter = Builders
69 .withNodeIdentifier(rootContainer)
71 Builders.containerBuilder()
72 .withNodeIdentifier(outerContainer)
74 Builders.augmentationBuilder()
75 .withNodeIdentifier(augmentation)
77 leaf).build()).build()).build();
79 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
80 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), leaf);
81 assertEquals(expectedFilter, filter);
85 public void testInAugmentLeafOverride() {
86 final LeafNode<Object> lastLeaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
87 .withValue("randomValue").build();
89 final ContainerNode expectedFilter = Builders
91 .withNodeIdentifier(rootContainer)
93 Builders.containerBuilder()
94 .withNodeIdentifier(outerContainer)
96 Builders.augmentationBuilder().withNodeIdentifier(augmentation)
97 .withChild(lastLeaf).build()).build()).build();
99 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
100 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), lastLeaf);
101 assertEquals(expectedFilter, filter);
105 public void testListChoice() {
106 final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(leafFromCase).withValue("").build();
107 final ContainerNode expectedFilter = Builders
109 .withNodeIdentifier(rootContainer)
111 Builders.mapBuilder()
112 .withNodeIdentifier(outerList)
114 Builders.mapEntryBuilder()
115 .withNodeIdentifier(outerListWithKey)
117 Builders.leafBuilder()
119 new NodeIdentifier(ID))
120 .withValue(1).build())
122 Builders.choiceBuilder()
123 .withNodeIdentifier(choice)
130 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
131 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase), leaf);
132 assertEquals(expectedFilter, filter);
136 public void testTopContainerLastChildOverride() {
137 final ContainerNode expectedStructure = Builders
139 .withNodeIdentifier(rootContainer)
141 Builders.mapBuilder()
142 .withNodeIdentifier(outerList)
144 Builders.mapEntryBuilder()
145 .withNodeIdentifier(outerListWithKey)
147 Builders.leafBuilder()
149 new NodeIdentifier(ID))
150 .withValue(1).build())
152 Builders.choiceBuilder()
153 .withNodeIdentifier(choice)
155 Builders.leafBuilder()
156 .withNodeIdentifier(leafFromCase)
158 .build()).build()).build()).build())
161 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
162 YangInstanceIdentifier.create(rootContainer), expectedStructure);
163 assertEquals(expectedStructure, filter);
167 public void testListLastChildOverride() {
168 final MapEntryNode outerListEntry = Builders
170 .withNodeIdentifier(outerListWithKey)
172 Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(ID))
173 .withValue(1).build()).build();
174 final MapNode lastChild = Builders.mapBuilder().withNodeIdentifier(this.outerList).withChild(outerListEntry)
176 final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer)
177 .withChild(lastChild).build();
179 NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
180 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey), outerListEntry);
181 assertEquals(expectedStructure, filter);
182 filter = ImmutableNodes.fromInstanceId(ctx,
183 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
184 assertEquals(expectedStructure, filter);
188 public void testLeafList() {
189 final ContainerNode expectedFilter = Builders
191 .withNodeIdentifier(rootContainer)
193 Builders.orderedLeafSetBuilder()
194 .withNodeIdentifier(leafList)
196 Builders.leafSetEntryBuilder().withNodeIdentifier(leafListWithValue)
197 .withValue(leafListWithValue.getValue()).build()).build()).build();
199 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
200 YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue));
201 assertEquals(expectedFilter, filter);