2 * Copyright (c) 2013 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.parser.impl;
10 import static org.junit.Assert.*;
13 import java.io.FileNotFoundException;
15 import java.net.URISyntaxException;
16 import java.text.ParseException;
17 import java.text.SimpleDateFormat;
18 import java.util.Collections;
19 import java.util.Date;
20 import java.util.List;
24 import org.junit.Before;
25 import org.junit.Test;
26 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
27 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
28 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
29 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
30 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
33 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
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.MustDefinition;
37 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
39 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
40 import org.opendaylight.yangtools.yang.model.api.UsesNode;
41 import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
43 public class GroupingTest {
44 private Set<Module> modules;
47 public void init() throws FileNotFoundException, URISyntaxException {
48 modules = TestUtils.loadModules(getClass().getResource("/model").toURI());
49 assertEquals(3, modules.size());
53 public void testRefine() {
54 Module testModule = TestUtils.findModule(modules, "foo");
55 ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName("peer");
56 ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName("destination");
58 Set<UsesNode> usesNodes = destination.getUses();
59 assertEquals(1, usesNodes.size());
60 UsesNode usesNode = usesNodes.iterator().next();
61 Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
62 assertEquals(4, refines.size());
64 LeafSchemaNode refineLeaf = null;
65 ContainerSchemaNode refineContainer = null;
66 ListSchemaNode refineList = null;
67 LeafSchemaNode refineInnerLeaf = null;
68 for (Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
69 SchemaNode value = entry.getValue();
70 if ("address".equals(value.getQName().getLocalName())) {
71 refineLeaf = (LeafSchemaNode) value;
72 } else if ("port".equals(value.getQName().getLocalName())) {
73 refineContainer = (ContainerSchemaNode) value;
74 } else if ("addresses".equals(value.getQName().getLocalName())) {
75 refineList = (ListSchemaNode) value;
76 } else if ("id".equals(value.getQName().getLocalName())) {
77 refineInnerLeaf = (LeafSchemaNode) value;
82 assertNotNull(refineLeaf);
83 assertEquals("IP address of target node", refineLeaf.getDescription());
84 assertEquals("address reference added by refine", refineLeaf.getReference());
85 assertFalse(refineLeaf.isConfiguration());
86 assertFalse(refineLeaf.getConstraints().isMandatory());
87 Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints().getMustConstraints();
88 assertEquals(1, leafMustConstraints.size());
89 MustDefinition leafMust = leafMustConstraints.iterator().next();
90 assertEquals("\"ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)\"", leafMust.toString());
91 assertEquals(1, refineLeaf.getUnknownSchemaNodes().size());
94 assertNotNull(refineContainer);
95 Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
96 assertTrue(mustConstraints.isEmpty());
97 assertEquals("description of port defined by refine", refineContainer.getDescription());
98 assertEquals("port reference added by refine", refineContainer.getReference());
99 assertFalse(refineContainer.isConfiguration());
100 assertTrue(refineContainer.isPresenceContainer());
103 assertNotNull(refineList);
104 assertEquals("description of addresses defined by refine", refineList.getDescription());
105 assertEquals("addresses reference added by refine", refineList.getReference());
106 assertFalse(refineList.isConfiguration());
107 assertEquals(2, (int) refineList.getConstraints().getMinElements());
108 assertEquals(12, (int) refineList.getConstraints().getMaxElements());
111 assertNotNull(refineInnerLeaf);
112 assertEquals("id of address", refineInnerLeaf.getDescription());
116 public void testGrouping() {
117 Module testModule = TestUtils.findModule(modules, "baz");
118 Set<GroupingDefinition> groupings = testModule.getGroupings();
119 assertEquals(1, groupings.size());
120 GroupingDefinition grouping = groupings.iterator().next();
121 Set<DataSchemaNode> children = grouping.getChildNodes();
122 assertEquals(5, children.size());
126 public void testUses() {
127 // suffix _u = added by uses
128 // suffix _g = defined in grouping
130 Module testModule = TestUtils.findModule(modules, "baz");
133 Set<GroupingDefinition> groupings = testModule.getGroupings();
134 assertEquals(1, groupings.size());
135 GroupingDefinition grouping = groupings.iterator().next();
137 testModule = TestUtils.findModule(modules, "foo");
139 // get node containing uses
140 ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName("peer");
141 ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName("destination");
144 Set<UsesNode> uses = destination.getUses();
145 assertEquals(1, uses.size());
147 // check uses process
148 AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) destination.getDataChildByName("data");
149 assertNotNull(data_u);
150 assertTrue(data_u.isAddedByUses());
152 AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName("data");
153 assertNotNull(data_g);
154 assertFalse(data_g.isAddedByUses());
155 assertFalse(data_u.equals(data_g));
157 ChoiceNode how_u = (ChoiceNode) destination.getDataChildByName("how");
158 assertNotNull(how_u);
159 TestUtils.checkIsAddedByUses(how_u, true);
160 assertEquals(2, how_u.getCases().size());
162 ChoiceNode how_g = (ChoiceNode) grouping.getDataChildByName("how");
163 assertNotNull(how_g);
164 TestUtils.checkIsAddedByUses(how_g, false);
165 assertEquals(2, how_g.getCases().size());
166 assertFalse(how_u.equals(how_g));
168 LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName("address");
169 assertNotNull(address_u);
170 assertEquals("1.2.3.4", address_u.getDefault());
171 assertEquals("IP address of target node", address_u.getDescription());
172 assertEquals("address reference added by refine", address_u.getReference());
173 assertFalse(address_u.isConfiguration());
174 assertTrue(address_u.isAddedByUses());
175 assertFalse(address_u.getConstraints().isMandatory());
177 LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName("address");
178 assertNotNull(address_g);
179 assertFalse(address_g.isAddedByUses());
180 assertNull(address_g.getDefault());
181 assertEquals("Target IP address", address_g.getDescription());
182 assertNull(address_g.getReference());
183 assertTrue(address_g.isConfiguration());
184 assertFalse(address_u.equals(address_g));
185 assertTrue(address_g.getConstraints().isMandatory());
187 ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName("port");
188 assertNotNull(port_u);
189 TestUtils.checkIsAddedByUses(port_u, true);
191 ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName("port");
192 assertNotNull(port_g);
193 TestUtils.checkIsAddedByUses(port_g, false);
194 assertFalse(port_u.equals(port_g));
196 ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName("addresses");
197 assertNotNull(addresses_u);
198 TestUtils.checkIsAddedByUses(addresses_u, true);
200 ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName("addresses");
201 assertNotNull(addresses_g);
202 TestUtils.checkIsAddedByUses(addresses_g, false);
203 assertFalse(addresses_u.equals(addresses_g));
205 // grouping defined by 'uses'
206 Set<GroupingDefinition> groupings_u = destination.getGroupings();
207 assertEquals(1, groupings_u.size());
208 GroupingDefinition grouping_u = groupings_u.iterator().next();
209 TestUtils.checkIsAddedByUses(grouping_u, true);
211 // grouping defined in 'grouping' node
212 Set<GroupingDefinition> groupings_g = grouping.getGroupings();
213 assertEquals(1, groupings_g.size());
214 GroupingDefinition grouping_g = groupings_g.iterator().next();
215 TestUtils.checkIsAddedByUses(grouping_g, false);
216 assertFalse(grouping_u.equals(grouping_g));
218 List<UnknownSchemaNode> nodes_u = destination.getUnknownSchemaNodes();
219 assertEquals(1, nodes_u.size());
220 UnknownSchemaNode node_u = nodes_u.get(0);
221 assertTrue(node_u.isAddedByUses());
223 List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
224 assertEquals(1, nodes_g.size());
225 UnknownSchemaNode node_g = nodes_g.get(0);
226 assertFalse(node_g.isAddedByUses());
227 assertFalse(node_u.equals(node_g));
231 public void testUsesUnderModule() {
232 // suffix _u = added by uses
233 // suffix _g = defined in grouping
235 Module testModule = TestUtils.findModule(modules, "baz");
238 Set<GroupingDefinition> groupings = testModule.getGroupings();
239 assertEquals(1, groupings.size());
240 GroupingDefinition grouping = groupings.iterator().next();
242 // get node containing uses
243 Module foo = TestUtils.findModule(modules, "foo");
246 Set<UsesNode> uses = foo.getUses();
247 assertEquals(1, uses.size());
249 // check uses process
250 AnyXmlSchemaNode data_u = (AnyXmlSchemaNode) foo.getDataChildByName("data");
251 assertNotNull(data_u);
252 assertTrue(data_u.isAddedByUses());
254 AnyXmlSchemaNode data_g = (AnyXmlSchemaNode) grouping.getDataChildByName("data");
255 assertNotNull(data_g);
256 assertFalse(data_g.isAddedByUses());
257 assertFalse(data_u.equals(data_g));
259 ChoiceNode how_u = (ChoiceNode) foo.getDataChildByName("how");
260 assertNotNull(how_u);
261 TestUtils.checkIsAddedByUses(how_u, true);
262 assertFalse(how_u.isAugmenting());
263 Set<ChoiceCaseNode> cases_u = how_u.getCases();
264 assertEquals(2, cases_u.size());
265 ChoiceCaseNode interval = how_u.getCaseNodeByName("interval");
266 assertFalse(interval.isAugmenting());
267 LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName("name");
268 assertTrue(name.isAugmenting());
269 LeafSchemaNode intervalLeaf = (LeafSchemaNode) interval.getDataChildByName("interval");
270 assertFalse(intervalLeaf.isAugmenting());
272 ChoiceNode how_g = (ChoiceNode) grouping.getDataChildByName("how");
273 assertNotNull(how_g);
274 TestUtils.checkIsAddedByUses(how_g, false);
275 assertFalse(how_u.equals(how_g));
277 LeafSchemaNode address_u = (LeafSchemaNode) foo.getDataChildByName("address");
278 assertNotNull(address_u);
279 assertNull(address_u.getDefault());
280 assertEquals("Target IP address", address_u.getDescription());
281 assertNull(address_u.getReference());
282 assertTrue(address_u.isConfiguration());
283 assertTrue(address_u.isAddedByUses());
285 LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName("address");
286 assertNotNull(address_g);
287 assertFalse(address_g.isAddedByUses());
288 assertNull(address_g.getDefault());
289 assertEquals("Target IP address", address_g.getDescription());
290 assertNull(address_g.getReference());
291 assertTrue(address_g.isConfiguration());
292 assertFalse(address_u.equals(address_g));
294 ContainerSchemaNode port_u = (ContainerSchemaNode) foo.getDataChildByName("port");
295 assertNotNull(port_u);
296 TestUtils.checkIsAddedByUses(port_u, true);
298 ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName("port");
299 assertNotNull(port_g);
300 TestUtils.checkIsAddedByUses(port_g, false);
301 assertFalse(port_u.equals(port_g));
303 ListSchemaNode addresses_u = (ListSchemaNode) foo.getDataChildByName("addresses");
304 assertNotNull(addresses_u);
305 TestUtils.checkIsAddedByUses(addresses_u, true);
307 ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName("addresses");
308 assertNotNull(addresses_g);
309 TestUtils.checkIsAddedByUses(addresses_g, false);
310 assertFalse(addresses_u.equals(addresses_g));
312 // grouping defined by 'uses'
313 Set<GroupingDefinition> groupings_u = foo.getGroupings();
314 assertEquals(1, groupings_u.size());
315 GroupingDefinition grouping_u = groupings_u.iterator().next();
316 TestUtils.checkIsAddedByUses(grouping_u, true);
318 // grouping defined in 'grouping' node
319 Set<GroupingDefinition> groupings_g = grouping.getGroupings();
320 assertEquals(1, groupings_g.size());
321 GroupingDefinition grouping_g = groupings_g.iterator().next();
322 TestUtils.checkIsAddedByUses(grouping_g, false);
323 assertFalse(grouping_u.equals(grouping_g));
325 List<UnknownSchemaNode> nodes_u = foo.getUnknownSchemaNodes();
326 assertEquals(1, nodes_u.size());
327 UnknownSchemaNode node_u = nodes_u.get(0);
328 assertTrue(node_u.isAddedByUses());
330 List<UnknownSchemaNode> nodes_g = grouping.getUnknownSchemaNodes();
331 assertEquals(1, nodes_g.size());
332 UnknownSchemaNode node_g = nodes_g.get(0);
333 assertFalse(node_g.isAddedByUses());
334 assertFalse(node_u.equals(node_g));
336 UsesNode un = uses.iterator().next();
337 Set<AugmentationSchema> usesAugments = un.getAugmentations();
338 assertEquals(1, usesAugments.size());
339 AugmentationSchema augment = usesAugments.iterator().next();
340 assertEquals("inner augment", augment.getDescription());
341 Set<DataSchemaNode> children = augment.getChildNodes();
342 assertEquals(1, children.size());
343 DataSchemaNode leaf = children.iterator().next();
344 assertTrue(leaf instanceof LeafSchemaNode);
345 assertEquals("name", leaf.getQName().getLocalName());
349 public void testCascadeUses() throws Exception {
350 File yangFile = new File(getClass().getResource("/grouping-test/cascade-uses.yang").toURI());
351 YangModelParser parser = new YangParserImpl();
352 modules = parser.parseYangModels(Collections.singletonList(yangFile));
353 assertEquals(1, modules.size());
355 Module testModule = TestUtils.findModule(modules, "cascade-uses");
356 Set<GroupingDefinition> groupings = testModule.getGroupings();
358 GroupingDefinition gu = null;
359 GroupingDefinition gv = null;
360 GroupingDefinition gx = null;
361 GroupingDefinition gy = null;
362 GroupingDefinition gz = null;
363 GroupingDefinition gzz = null;
364 for (GroupingDefinition gd : groupings) {
365 String name = gd.getQName().getLocalName();
394 URI expectedNS = URI.create("urn:grouping:cascade-uses");
395 Date expectedRev = new SimpleDateFormat("yyyy-MM-dd").parse("2013-07-18");
396 String expectedPref = "cu";
397 SchemaPath expectedPath;
400 Set<DataSchemaNode> childNodes = gu.getChildNodes();
401 assertEquals(7, childNodes.size());
402 LeafSchemaNode leafGroupingU = null;
403 for (DataSchemaNode childNode : childNodes) {
404 if ("leaf-grouping-U".equals(childNode.getQName().getLocalName())) {
405 leafGroupingU = (LeafSchemaNode) childNode;
407 TestUtils.checkIsAddedByUses(childNode, true);
410 assertNotNull(leafGroupingU);
411 assertFalse(leafGroupingU.isAddedByUses());
414 childNodes = gv.getChildNodes();
415 assertEquals(4, childNodes.size());
416 LeafSchemaNode leafGroupingV = null;
417 ContainerSchemaNode containerGroupingV = null;
418 for (DataSchemaNode childNode : childNodes) {
419 if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
420 leafGroupingV = (LeafSchemaNode) childNode;
421 } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
422 containerGroupingV = (ContainerSchemaNode) childNode;
424 TestUtils.checkIsAddedByUses(childNode, true);
427 assertNotNull(leafGroupingV);
428 assertFalse(leafGroupingV.isAddedByUses());
430 // grouping-V/container-grouping-V
431 assertNotNull(containerGroupingV);
432 assertFalse(containerGroupingV.isAddedByUses());
433 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
434 "container-grouping-V");
435 assertEquals(expectedPath, containerGroupingV.getPath());
436 childNodes = containerGroupingV.getChildNodes();
437 assertEquals(2, childNodes.size());
438 for (DataSchemaNode childNode : childNodes) {
439 TestUtils.checkIsAddedByUses(childNode, true);
442 // grouping-V/container-grouping-V/leaf-grouping-X
443 LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName("leaf-grouping-X");
444 assertNotNull(leafXinContainerV);
445 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
446 "container-grouping-V", "leaf-grouping-X");
447 assertEquals(expectedPath, leafXinContainerV.getPath());
448 // grouping-V/container-grouping-V/leaf-grouping-Y
449 LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName("leaf-grouping-Y");
450 assertNotNull(leafYinContainerV);
451 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-V",
452 "container-grouping-V", "leaf-grouping-Y");
453 assertEquals(expectedPath, leafYinContainerV.getPath());
456 childNodes = gx.getChildNodes();
457 assertEquals(2, childNodes.size());
459 // grouping-X/leaf-grouping-X
460 LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName("leaf-grouping-X");
461 assertNotNull(leafXinGX);
462 assertFalse(leafXinGX.isAddedByUses());
463 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-X",
465 assertEquals(expectedPath, leafXinGX.getPath());
467 // grouping-X/leaf-grouping-Y
468 LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName("leaf-grouping-Y");
469 assertNotNull(leafYinGX);
470 assertTrue(leafYinGX.isAddedByUses());
471 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-X",
473 assertEquals(expectedPath, leafYinGX.getPath());
476 childNodes = gy.getChildNodes();
477 assertEquals(1, childNodes.size());
479 // grouping-Y/leaf-grouping-Y
480 LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName("leaf-grouping-Y");
481 assertNotNull(leafYinGY);
482 assertFalse(leafYinGY.isAddedByUses());
483 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-Y",
485 assertEquals(expectedPath, leafYinGY.getPath());
488 childNodes = gz.getChildNodes();
489 assertEquals(1, childNodes.size());
491 // grouping-Z/leaf-grouping-Z
492 LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName("leaf-grouping-Z");
493 assertNotNull(leafZinGZ);
494 assertFalse(leafZinGZ.isAddedByUses());
495 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-Z",
497 assertEquals(expectedPath, leafZinGZ.getPath());
500 childNodes = gzz.getChildNodes();
501 assertEquals(1, childNodes.size());
503 // grouping-ZZ/leaf-grouping-ZZ
504 LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName("leaf-grouping-ZZ");
505 assertNotNull(leafZZinGZZ);
506 assertFalse(leafZZinGZZ.isAddedByUses());
507 expectedPath = TestUtils.createPath(true, expectedNS, expectedRev, expectedPref, "grouping-ZZ",
509 assertEquals(expectedPath, leafZZinGZZ.getPath());