2 * Copyright (c) 2017 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
9 package org.opendaylight.yangtools.yang.data.jaxen;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertSame;
14 import static org.junit.Assert.assertTrue;
16 import com.google.common.collect.BiMap;
17 import com.google.common.collect.HashBiMap;
18 import com.google.common.collect.ImmutableList;
19 import com.google.common.collect.ImmutableMap;
20 import com.google.common.collect.Maps;
23 import org.jaxen.Function;
24 import org.junit.Test;
25 import org.opendaylight.yangtools.yang.common.QName;
26 import org.opendaylight.yangtools.yang.common.QNameModule;
27 import org.opendaylight.yangtools.yang.common.Revision;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
31 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
32 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
35 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
36 import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
37 import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
38 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
39 import org.opendaylight.yangtools.yang.data.jaxen.api.XPathDocument;
40 import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
41 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
42 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
44 public class DerefXPathFunctionTest {
46 private static JaxenSchemaContextFactory jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
48 private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo-ns"), Revision.of("2017-04-03"));
49 private static final QName MY_CONTAINER = QName.create(FOO_MODULE, "my-container");
50 private static final QName MY_INNER_CONTAINER = QName.create(FOO_MODULE, "my-inner-container");
51 private static final QName MY_LIST = QName.create(FOO_MODULE, "my-list");
52 private static final QName KEY_LEAF_A = QName.create(FOO_MODULE, "key-leaf-a");
53 private static final QName KEY_LEAF_B = QName.create(FOO_MODULE, "key-leaf-b");
54 private static final QName IID_LEAF = QName.create(FOO_MODULE, "iid-leaf");
55 private static final QName REFERENCED_LEAF = QName.create(FOO_MODULE, "referenced-leaf");
56 private static final QName REFERENCED_LEAFLIST = QName.create(FOO_MODULE, "referenced-leaf-list");
57 private static final QName ABS_LEAFREF_LEAF = QName.create(FOO_MODULE, "abs-leafref-leaf");
58 private static final QName REL_LEAFREF_LEAF = QName.create(FOO_MODULE, "rel-leafref-leaf");
59 private static final QName LEAFLIST_LEAFREF_LEAF = QName.create(FOO_MODULE, "leaf-list-leafref-leaf");
60 private static final QName ORDINARY_LEAF_A = QName.create(FOO_MODULE, "ordinary-leaf-a");
61 private static final QName ORDINARY_LEAF_B = QName.create(FOO_MODULE, "ordinary-leaf-b");
64 public void testDerefFunctionForInstanceIdentifier() throws Exception {
65 final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
66 "/yang-xpath-functions-test/deref-function-iid/foo.yang");
67 assertNotNull(schemaContext);
69 final XPathSchemaContext jaxenSchemaContext = jaxenSchemaContextFactory.createContext(schemaContext);
71 final LeafNode<?> referencedLeafNode = Builders.leafBuilder().withNodeIdentifier(
72 new NodeIdentifier(REFERENCED_LEAF)).withValue("referenced-leaf-node-value").build();
74 final XPathDocument jaxenDocument = jaxenSchemaContext.createDocument(buildMyContainerNodeForIIdTest(
77 final BiMap<String, QNameModule> converterBiMap = HashBiMap.create();
78 converterBiMap.put("foo-prefix", FOO_MODULE);
80 final NormalizedNodeContextSupport normalizedNodeContextSupport = NormalizedNodeContextSupport.create(
81 (JaxenDocument) jaxenDocument, Maps.asConverter(converterBiMap));
83 final NormalizedNodeContext normalizedNodeContext = normalizedNodeContextSupport.createContext(
84 buildPathToIIdLeafNode());
86 final Function derefFunction = normalizedNodeContextSupport.getFunctionContext()
87 .getFunction(null, null, "deref");
88 final Object derefResult = derefFunction.call(normalizedNodeContext, ImmutableList.of());
89 assertNotNull(derefResult);
90 assertTrue(derefResult instanceof LeafNode<?>);
91 assertEquals(referencedLeafNode, derefResult);
95 public void testDerefFunctionForLeafref() throws Exception {
96 // tests absolute and relative leafref that references a leaf node
97 final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
98 "/yang-xpath-functions-test/deref-function-leafref/foo.yang");
99 assertNotNull(schemaContext);
101 final XPathSchemaContext jaxenSchemaContext = jaxenSchemaContextFactory.createContext(schemaContext);
103 final LeafNode<?> referencedLeafNode = Builders.leafBuilder().withNodeIdentifier(
104 new NodeIdentifier(REFERENCED_LEAF)).withValue("referenced-leaf-node-value").build();
106 final XPathDocument jaxenDocument = jaxenSchemaContext.createDocument(buildMyContainerNodeForLeafrefTest(
107 referencedLeafNode));
109 final BiMap<String, QNameModule> converterBiMap = HashBiMap.create();
110 converterBiMap.put("foo-prefix", FOO_MODULE);
112 final NormalizedNodeContextSupport normalizedNodeContextSupport = NormalizedNodeContextSupport.create(
113 (JaxenDocument) jaxenDocument, Maps.asConverter(converterBiMap));
115 final YangInstanceIdentifier absLeafrefPath = YangInstanceIdentifier.of(MY_INNER_CONTAINER)
116 .node(ABS_LEAFREF_LEAF);
117 NormalizedNodeContext normalizedNodeContext = normalizedNodeContextSupport.createContext(absLeafrefPath);
119 final Function derefFunction = normalizedNodeContextSupport.getFunctionContext()
120 .getFunction(null, null, "deref");
121 Object derefResult = derefFunction.call(normalizedNodeContext, ImmutableList.of());
122 assertNotNull(derefResult);
123 assertTrue(derefResult instanceof LeafNode<?>);
124 assertEquals(referencedLeafNode, derefResult);
126 final YangInstanceIdentifier relLeafrefPath = YangInstanceIdentifier.of(MY_INNER_CONTAINER)
127 .node(REL_LEAFREF_LEAF);
128 normalizedNodeContext = normalizedNodeContextSupport.createContext(relLeafrefPath);
130 derefResult = derefFunction.call(normalizedNodeContext, ImmutableList.of());
131 assertNotNull(derefResult);
132 assertTrue(derefResult instanceof LeafNode<?>);
133 assertEquals(referencedLeafNode, derefResult);
137 public void testDerefFunctionForLeafref2() throws Exception {
138 // tests leafref that references a leaf-list node
139 final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
140 "/yang-xpath-functions-test/deref-function-leafref/foo.yang");
141 assertNotNull(schemaContext);
143 final XPathSchemaContext jaxenSchemaContext = jaxenSchemaContextFactory.createContext(schemaContext);
145 final SystemLeafSetNode<?> referencedLeafListNode = Builders.leafSetBuilder()
146 .withNodeIdentifier(new NodeIdentifier(REFERENCED_LEAFLIST))
147 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
148 new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-a"))
149 .withValue("referenced-node-entry-value-a").build())
150 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
151 new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-b"))
152 .withValue("referenced-node-entry-value-b").build())
153 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
154 new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-c"))
155 .withValue("referenced-node-entry-value-c").build())
158 final XPathDocument jaxenDocument = jaxenSchemaContext.createDocument(buildMyContainerNodeForLeafrefTest(
159 referencedLeafListNode));
161 final BiMap<String, QNameModule> converterBiMap = HashBiMap.create();
162 converterBiMap.put("foo-prefix", FOO_MODULE);
164 final NormalizedNodeContextSupport normalizedNodeContextSupport = NormalizedNodeContextSupport.create(
165 (JaxenDocument) jaxenDocument, Maps.asConverter(converterBiMap));
167 final YangInstanceIdentifier leafListLeafrefPath = YangInstanceIdentifier.of(MY_INNER_CONTAINER)
168 .node(LEAFLIST_LEAFREF_LEAF);
169 final NormalizedNodeContext normalizedNodeContext = normalizedNodeContextSupport
170 .createContext(leafListLeafrefPath);
172 final Function derefFunction = normalizedNodeContextSupport.getFunctionContext()
173 .getFunction(null, null, "deref");
174 Object derefResult = derefFunction.call(normalizedNodeContext, ImmutableList.of());
175 assertNotNull(derefResult);
176 assertTrue(derefResult instanceof NormalizedNode);
178 final LeafSetEntryNode<?> referencedLeafListNodeEntry = referencedLeafListNode.childByArg(
179 new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-b"));
180 assertSame(referencedLeafListNodeEntry, derefResult);
183 private static ContainerNode buildMyContainerNodeForIIdTest(final LeafNode<?> referencedLeafNode) {
184 final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "key-value-a", KEY_LEAF_B, "key-value-b");
185 final YangInstanceIdentifier iidPath = YangInstanceIdentifier.of(MY_CONTAINER).node(MY_LIST)
186 .node(NodeIdentifierWithPredicates.of(MY_LIST, keyValues)).node(REFERENCED_LEAF);
188 final LeafNode<?> iidLeafNode = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(IID_LEAF))
189 .withValue(iidPath).build();
191 final SystemMapNode myListNode = Builders.mapBuilder()
192 .withNodeIdentifier(new NodeIdentifier(MY_LIST))
193 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
194 NodeIdentifierWithPredicates.of(MY_LIST, keyValues))
195 .withChild(iidLeafNode)
196 .withChild(referencedLeafNode).build())
199 final ContainerNode myContainerNode = Builders.containerBuilder().withNodeIdentifier(
200 new NodeIdentifier(MY_CONTAINER)).withChild(myListNode).build();
201 return myContainerNode;
204 private static YangInstanceIdentifier buildPathToIIdLeafNode() {
205 final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "key-value-a", KEY_LEAF_B, "key-value-b");
206 final YangInstanceIdentifier path = YangInstanceIdentifier.of(MY_LIST)
207 .node(NodeIdentifierWithPredicates.of(MY_LIST, keyValues)).node(IID_LEAF);
211 // variant for a leafref that references a leaf
212 private static ContainerNode buildMyContainerNodeForLeafrefTest(final LeafNode<?> referencedLeafNode) {
213 final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "value-a", KEY_LEAF_B, "value-b");
215 final LeafNode<?> absLeafrefNode = Builders.leafBuilder()
216 .withNodeIdentifier(new NodeIdentifier(ABS_LEAFREF_LEAF))
217 .withValue("referenced-leaf-node-value").build();
218 final LeafNode<?> relLeafrefNode = Builders.leafBuilder()
219 .withNodeIdentifier(new NodeIdentifier(REL_LEAFREF_LEAF))
220 .withValue("referenced-leaf-node-value").build();
221 final LeafNode<?> ordinaryLeafANode = Builders.leafBuilder().withNodeIdentifier(
222 new NodeIdentifier(ORDINARY_LEAF_A)).withValue("value-a").build();
223 final LeafNode<?> ordinaryLeafBNode = Builders.leafBuilder().withNodeIdentifier(
224 new NodeIdentifier(ORDINARY_LEAF_B)).withValue("value-b").build();
226 final SystemMapNode myListNode = Builders.mapBuilder()
227 .withNodeIdentifier(new NodeIdentifier(MY_LIST))
228 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
229 NodeIdentifierWithPredicates.of(MY_LIST, keyValues))
230 .withChild(referencedLeafNode).build())
233 final ContainerNode myInnerContainerNode = Builders.containerBuilder().withNodeIdentifier(
234 new NodeIdentifier(MY_INNER_CONTAINER))
235 .withChild(absLeafrefNode)
236 .withChild(relLeafrefNode)
237 .withChild(ordinaryLeafANode)
238 .withChild(ordinaryLeafBNode).build();
240 final ContainerNode myContainerNode = Builders.containerBuilder().withNodeIdentifier(
241 new NodeIdentifier(MY_CONTAINER))
242 .withChild(myListNode)
243 .withChild(myInnerContainerNode).build();
244 return myContainerNode;
247 // variant for a leafref that references a leaf-list
248 private static ContainerNode buildMyContainerNodeForLeafrefTest(final SystemLeafSetNode<?> referencedLeafListNode) {
249 final LeafNode<?> leafListLeafrefNode = Builders.leafBuilder().withNodeIdentifier(
250 new NodeIdentifier(LEAFLIST_LEAFREF_LEAF)).withValue("referenced-node-entry-value-b").build();
252 final LeafNode<?> ordinaryLeafANode = Builders.leafBuilder().withNodeIdentifier(
253 new NodeIdentifier(ORDINARY_LEAF_A)).withValue("value-a").build();
254 final LeafNode<?> ordinaryLeafBNode = Builders.leafBuilder().withNodeIdentifier(
255 new NodeIdentifier(ORDINARY_LEAF_B)).withValue("value-b").build();
257 final ContainerNode myInnerContainerNode = Builders.containerBuilder().withNodeIdentifier(
258 new NodeIdentifier(MY_INNER_CONTAINER))
259 .withChild(leafListLeafrefNode)
260 .withChild(ordinaryLeafANode)
261 .withChild(ordinaryLeafBNode).build();
263 final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "value-a", KEY_LEAF_B, "value-b");
264 final SystemMapNode myListNode = Builders.mapBuilder()
265 .withNodeIdentifier(new NodeIdentifier(MY_LIST))
266 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
267 NodeIdentifierWithPredicates.of(MY_LIST, keyValues))
268 .withChild(referencedLeafListNode).build())
271 final ContainerNode myContainerNode = Builders.containerBuilder()
272 .withNodeIdentifier(new NodeIdentifier(MY_CONTAINER))
273 .withChild(myListNode)
274 .withChild(myInnerContainerNode).build();
275 return myContainerNode;