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.io.IOException;
13 import java.net.URISyntaxException;
14 import java.util.Collections;
15 import org.junit.BeforeClass;
16 import org.junit.Test;
17 import org.opendaylight.yangtools.yang.common.QName;
18 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
23 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
24 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
25 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
26 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
27 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
28 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
29 import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
30 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
31 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
33 public class InstanceIdToNodesTest {
35 private static final String NS = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:normalization:test";
36 private static final String REVISION = "2014-03-13";
37 private static final QName ID = QName.create(NS, REVISION, "id");
38 private static SchemaContext ctx;
40 private final NodeIdentifier rootContainer = new NodeIdentifier(QName.create(NS, REVISION, "test"));
41 private final NodeIdentifier outerContainer = new NodeIdentifier(QName.create(NS, REVISION, "outer-container"));
42 private final NodeIdentifier augmentedLeaf = new NodeIdentifier(QName.create(NS, REVISION, "augmented-leaf"));
43 private final AugmentationIdentifier augmentation = new AugmentationIdentifier(
44 Collections.singleton(augmentedLeaf.getNodeType()));
46 private final NodeIdentifier outerList = new NodeIdentifier(
47 QName.create(NS, REVISION, "outer-list"));
48 private final NodeIdentifierWithPredicates outerListWithKey = new NodeIdentifierWithPredicates(
49 QName.create(NS, REVISION, "outer-list"), ID, 1);
50 private final NodeIdentifier choice = new NodeIdentifier(QName.create(NS, REVISION, "outer-choice"));
51 private final NodeIdentifier leafFromCase = new NodeIdentifier(QName.create(NS, REVISION, "one"));
53 private final NodeIdentifier leafList = new NodeIdentifier(QName.create(NS, REVISION, "ordered-leaf-list"));
54 private final NodeWithValue<?> leafListWithValue = new NodeWithValue<>(
55 leafList.getNodeType(), "abcd");
57 static SchemaContext createTestContext() throws URISyntaxException, ReactorException, IOException,
58 YangSyntaxErrorException {
59 return YangParserTestUtils.parseYangResources(InstanceIdToNodesTest.class, "/filter-test.yang");
63 public static void setUp() throws Exception {
64 ctx = createTestContext();
69 public void testInAugment() throws Exception {
70 final ContainerNode expectedFilter = Builders
72 .withNodeIdentifier(rootContainer)
74 Builders.containerBuilder()
75 .withNodeIdentifier(outerContainer)
77 Builders.augmentationBuilder()
78 .withNodeIdentifier(augmentation)
80 Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
81 .build()).build()).build()).build();
83 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
84 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf));
85 assertEquals(expectedFilter, filter);
89 public void testInAugmentLeafOverride() throws Exception {
90 final LeafNode<Object> lastLeaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
91 .withValue("randomValue").build();
93 final ContainerNode expectedFilter = Builders
95 .withNodeIdentifier(rootContainer)
97 Builders.containerBuilder()
98 .withNodeIdentifier(outerContainer)
100 Builders.augmentationBuilder().withNodeIdentifier(augmentation)
101 .withChild(lastLeaf).build()).build()).build();
103 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
104 YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), lastLeaf);
105 assertEquals(expectedFilter, filter);
109 public void testListChoice() throws Exception {
110 final ContainerNode expectedFilter = Builders
112 .withNodeIdentifier(rootContainer)
114 Builders.mapBuilder()
115 .withNodeIdentifier(outerList)
117 Builders.mapEntryBuilder()
118 .withNodeIdentifier(outerListWithKey)
120 Builders.leafBuilder()
122 new NodeIdentifier(ID))
123 .withValue(1).build())
125 Builders.choiceBuilder()
126 .withNodeIdentifier(choice)
128 Builders.leafBuilder()
129 .withNodeIdentifier(leafFromCase)
130 .build()).build()).build()).build())
133 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
134 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase));
135 assertEquals(expectedFilter, filter);
139 public void testTopContainerLastChildOverride() throws Exception {
140 final ContainerNode expectedStructure = Builders
142 .withNodeIdentifier(rootContainer)
144 Builders.mapBuilder()
145 .withNodeIdentifier(outerList)
147 Builders.mapEntryBuilder()
148 .withNodeIdentifier(outerListWithKey)
150 Builders.leafBuilder()
152 new NodeIdentifier(ID))
153 .withValue(1).build())
155 Builders.choiceBuilder()
156 .withNodeIdentifier(choice)
158 Builders.leafBuilder()
159 .withNodeIdentifier(leafFromCase)
160 .build()).build()).build()).build())
163 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
164 YangInstanceIdentifier.create(rootContainer), expectedStructure);
165 assertEquals(expectedStructure, filter);
169 public void testListLastChildOverride() throws Exception {
170 final MapEntryNode outerListEntry = Builders
172 .withNodeIdentifier(outerListWithKey)
174 Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(ID))
175 .withValue(1).build()).build();
176 final MapNode lastChild = Builders.mapBuilder().withNodeIdentifier(this.outerList).withChild(outerListEntry)
178 final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer)
179 .withChild(lastChild).build();
181 NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
182 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey), outerListEntry);
183 assertEquals(expectedStructure, filter);
184 filter = ImmutableNodes.fromInstanceId(ctx,
185 YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
186 assertEquals(expectedStructure, filter);
190 public void testLeafList() throws Exception {
191 final ContainerNode expectedFilter = Builders
193 .withNodeIdentifier(rootContainer)
195 Builders.orderedLeafSetBuilder()
196 .withNodeIdentifier(leafList)
198 Builders.leafSetEntryBuilder().withNodeIdentifier(leafListWithValue)
199 .withValue(leafListWithValue.getValue()).build()).build()).build();
201 final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx,
202 YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue));
203 assertEquals(expectedFilter, filter);