2 * Copyright (c) 2015 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.leafref.context.test.retest;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertTrue;
13 import java.io.FileNotFoundException;
14 import java.net.URISyntaxException;
15 import java.util.Arrays;
16 import java.util.HashMap;
19 import org.apache.log4j.BasicConfigurator;
20 import org.junit.BeforeClass;
21 import org.junit.Test;
22 import org.opendaylight.yangtools.yang.common.QName;
23 import org.opendaylight.yangtools.yang.common.QNameModule;
24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
28 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
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.LeafSetEntryNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
35 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
36 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
37 import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
38 import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
39 import org.opendaylight.yangtools.yang.data.impl.RetestUtils;
40 import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContext;
41 import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefDataValidationFailedException;
42 import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefValidatation;
43 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
44 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
45 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
46 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
47 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
48 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
49 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
50 import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
51 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
52 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
53 import org.opendaylight.yangtools.yang.model.api.Module;
54 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
55 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
56 import org.slf4j.Logger;
57 import org.slf4j.LoggerFactory;
59 public class DataTreeCandidateValidatorTest {
61 private static SchemaContext context;
62 private static Module valModule;
63 private static QNameModule valModuleQname;
64 private static LeafRefContext rootLeafRefContext;
65 public static TipProducingDataTree inMemoryDataTree;
67 private static QName odl;
68 private static QName project;
69 private static QName name;
70 private static QName desc;
71 private static QName lead;
72 private static QName owner;
73 private static QName odlContributor;
74 private static QName contributor;
75 private static QName odlProjectName;
76 private static QName odlProjectDesc;
77 private static QName login;
78 private static QName contributorName;
79 private static QName l1;
80 private static QName l2;
81 private static QName con1;
82 private static QName ch1;
83 private static QName ch2;
84 private static QName leafrefInChoice;
85 private static QName listInChoice;
87 private static QName leafrefInChoiceToChoice;
88 private static QName con3;
89 private static QName list3InChoice;
90 private static QName l3;
91 private static QName choiceInCon3;
93 private static QName listInChoiceKey;
94 private static QName k;
96 private static QName leafrefLeafList;
98 private static final Logger LOG = LoggerFactory.getLogger(DataTreeCandidateValidatorTest.class);
99 private static final String NEW_LINE = System.getProperty("line.separator");
102 BasicConfigurator.configure();
106 public static void init() throws FileNotFoundException, ReactorException,
110 initLeafRefContext();
118 private static void initSchemaContext() throws URISyntaxException,
119 FileNotFoundException, ReactorException {
120 final File resourceFile = new File(DataTreeCandidateValidatorTest.class
121 .getResource("/leafref-validation/leafref-validation.yang")
123 final File resourceDir = resourceFile.getParentFile();
125 context = RetestUtils.parseYangSources(Arrays.asList(resourceDir
128 final Set<Module> modules = context.getModules();
129 for (final Module module : modules) {
130 if (module.getName().equals("leafref-validation")) {
135 valModuleQname = valModule.getQNameModule();
138 private static void initLeafRefContext() {
139 rootLeafRefContext = LeafRefContext.create(context);
142 private static void initQnames() {
143 odl = QName.create(valModuleQname, "odl-project");
144 project = QName.create(valModuleQname, "project");
145 name = QName.create(valModuleQname, "name");
146 desc = QName.create(valModuleQname, "desc");
147 lead = QName.create(valModuleQname, "project-lead");
148 owner = QName.create(valModuleQname, "project-owner");
150 odlContributor = QName.create(valModuleQname, "odl-contributor");
151 contributor = QName.create(valModuleQname, "contributor");
152 odlProjectName = QName.create(valModuleQname, "odl-project-name");
153 login = QName.create(valModuleQname, "login");
154 contributorName = QName.create(valModuleQname, "contributor-name");
156 con1 = QName.create(valModuleQname, "con1");
157 l1 = QName.create(valModuleQname, "l1");
158 l2 = QName.create(valModuleQname, "l2");
159 odlProjectDesc = QName.create(valModuleQname, "odl-project-desc");
161 ch1 = QName.create(valModuleQname, "ch1");
162 ch2 = QName.create(valModuleQname, "ch2");
163 leafrefInChoice = QName.create(valModuleQname, "leafref-in-choice");
164 listInChoice = QName.create(valModuleQname, "list-in-choice");
166 leafrefInChoiceToChoice = QName.create(valModuleQname,
167 "leafref-in-choice-to-choice");
168 con3 = QName.create(valModuleQname, "con3");
169 list3InChoice = QName.create(valModuleQname, "list3-in-choice");
170 l3 = QName.create(valModuleQname, "l3");
171 choiceInCon3 = QName.create(valModuleQname, "choice-in-con3");
173 listInChoiceKey = QName.create(valModuleQname, "list-in-choice-key");
174 k = QName.create(valModuleQname, "k");
176 leafrefLeafList = QName.create(valModuleQname, "leafref-leaf-list");
180 private static void initDataTree() {
181 inMemoryDataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
182 inMemoryDataTree.setSchemaContext(context);
184 final DataTreeModification initialDataTreeModification = inMemoryDataTree
185 .takeSnapshot().newModification();
187 final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule
188 .getDataChildByName(odl);
190 final ContainerNode odlProjectContainer = createOdlContainer(odlProjContSchemaNode);
192 final YangInstanceIdentifier path = YangInstanceIdentifier.of(odl);
193 initialDataTreeModification.write(path, odlProjectContainer);
194 initialDataTreeModification.ready();
196 final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
197 .prepare(initialDataTreeModification);
198 inMemoryDataTree.commit(writeContributorsCandidate);
203 public void dataTreeCanditateValidationTest() {
217 private static void writeContributors() {
219 final ContainerSchemaNode contributorContSchemaNode = (ContainerSchemaNode) valModule
220 .getDataChildByName(odlContributor);
222 final ContainerNode contributorContainer = createBasicContributorContainer(contributorContSchemaNode);
224 final YangInstanceIdentifier contributorPath = YangInstanceIdentifier
226 final DataTreeModification writeModification = inMemoryDataTree
227 .takeSnapshot().newModification();
228 writeModification.write(contributorPath, contributorContainer);
229 writeModification.ready();
231 final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
232 .prepare(writeModification);
234 LOG.debug("*************************");
235 LOG.debug("Before write of contributors: ");
236 LOG.debug("*************************");
237 LOG.debug(inMemoryDataTree.toString());
239 boolean exception = false;
241 LeafRefValidatation.validate(writeContributorsCandidate,
243 } catch (final LeafRefDataValidationFailedException e) {
244 LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
245 assertEquals(3, e.getValidationsErrorsCount());
249 inMemoryDataTree.commit(writeContributorsCandidate);
251 LOG.debug("*************************");
252 LOG.debug("After write of contributors: ");
253 LOG.debug("*************************");
254 LOG.debug(inMemoryDataTree.toString());
256 assertTrue(exception);
260 private static void writeIntoMapEntry() {
262 final Map<QName, Object> keys = new HashMap<QName, Object>();
263 keys.put(name, "New Project");
264 final NodeIdentifierWithPredicates mapEntryPath = new NodeIdentifierWithPredicates(
267 final YangInstanceIdentifier leaderPath = YangInstanceIdentifier
268 .of(odl).node(project).node(mapEntryPath).node(lead);
270 final LeafNode<String> leader = ImmutableNodes.leafNode(lead,
273 final DataTreeModification writeModification = inMemoryDataTree
274 .takeSnapshot().newModification();
275 writeModification.write(leaderPath, leader);
276 writeModification.ready();
278 final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
279 .prepare(writeModification);
281 LOG.debug("*************************");
282 LOG.debug("Before write into map entry (update of leader name): ");
283 LOG.debug("*************************");
284 LOG.debug(inMemoryDataTree.toString());
286 boolean exception = false;
288 LeafRefValidatation.validate(writeContributorsCandidate,
290 } catch (final LeafRefDataValidationFailedException e) {
291 LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
292 assertEquals(1, e.getValidationsErrorsCount());
296 inMemoryDataTree.commit(writeContributorsCandidate);
298 LOG.debug("*************************");
299 LOG.debug("After write into map entry (update of leader name): ");
300 LOG.debug("*************************");
301 LOG.debug(inMemoryDataTree.toString());
303 assertTrue(exception);
307 private static void writeMapEntry() {
309 final Map<QName, Object> keys = new HashMap<QName, Object>();
310 keys.put(name, "New Project");
311 final NodeIdentifierWithPredicates mapEntryPath = new NodeIdentifierWithPredicates(
314 final YangInstanceIdentifier newOdlProjectMapEntryPath = YangInstanceIdentifier
315 .of(odl).node(project).node(mapEntryPath);
317 final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule
318 .getDataChildByName(odl);
319 final ListSchemaNode projListSchemaNode = (ListSchemaNode) odlProjContSchemaNode
320 .getDataChildByName(project);
321 final MapEntryNode newProjectMapEntry = createProjectListEntry(
322 "New Project", "New Project description ...",
323 "Leader of New Project", "Owner of New Project",
326 final DataTreeModification writeModification = inMemoryDataTree
327 .takeSnapshot().newModification();
328 writeModification.write(newOdlProjectMapEntryPath, newProjectMapEntry);
329 writeModification.ready();
331 final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
332 .prepare(writeModification);
334 LOG.debug("*************************");
335 LOG.debug("Before map entry write: ");
336 LOG.debug("*************************");
337 LOG.debug(inMemoryDataTree.toString());
339 boolean exception = false;
341 LeafRefValidatation.validate(writeContributorsCandidate,
343 } catch (final LeafRefDataValidationFailedException e) {
344 LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
345 assertEquals(2, e.getValidationsErrorsCount());
349 inMemoryDataTree.commit(writeContributorsCandidate);
351 LOG.debug("*************************");
352 LOG.debug("After map entry write: ");
353 LOG.debug("*************************");
354 LOG.debug(inMemoryDataTree.toString());
356 assertTrue(exception);
360 private static void write() {
362 final ContainerSchemaNode contributorContSchemaNode = (ContainerSchemaNode) valModule
363 .getDataChildByName(odlContributor);
365 final ContainerNode contributorContainer = createContributorContainer(contributorContSchemaNode);
367 final YangInstanceIdentifier contributorPath = YangInstanceIdentifier
369 final DataTreeModification writeModification = inMemoryDataTree
370 .takeSnapshot().newModification();
371 writeModification.write(contributorPath, contributorContainer);
373 writeModification.write(YangInstanceIdentifier.of(l1),
374 ImmutableNodes.leafNode(l1, "Leafref l1 under the root"));
376 .write(YangInstanceIdentifier.of(l2), ImmutableNodes.leafNode(
377 l2, "Leafref target l2 under the root"));
379 writeModification.ready();
380 final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
381 .prepare(writeModification);
383 LOG.debug("*************************");
384 LOG.debug("Before write: ");
385 LOG.debug("*************************");
386 LOG.debug(inMemoryDataTree.toString());
388 boolean exception = false;
390 LeafRefValidatation.validate(writeContributorsCandidate,
392 } catch (final LeafRefDataValidationFailedException e) {
393 LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
394 assertEquals(12, e.getValidationsErrorsCount());
398 inMemoryDataTree.commit(writeContributorsCandidate);
400 LOG.debug("*************************");
401 LOG.debug("After write: ");
402 LOG.debug("*************************");
403 LOG.debug(inMemoryDataTree.toString());
405 assertTrue(exception);
408 private static void write2() {
410 final ContainerSchemaNode odlCon = (ContainerSchemaNode) valModule
411 .getDataChildByName(odl);
412 final ContainerSchemaNode con1Con = (ContainerSchemaNode) odlCon
413 .getDataChildByName(con1);
414 final LeafNode<String> l1Leaf = ImmutableNodes.leafNode(l1, "l1 value");
415 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
416 .containerBuilder(con1Con);
417 containerBuilder.addChild(l1Leaf);
418 final ContainerNode con1Node = containerBuilder.build();
420 final YangInstanceIdentifier con1Path = YangInstanceIdentifier.of(odl)
422 final DataTreeModification writeModification = inMemoryDataTree
423 .takeSnapshot().newModification();
424 writeModification.write(con1Path, con1Node);
426 final ChoiceNode choiceNode = createChoiceNode();
427 final YangInstanceIdentifier choicePath = YangInstanceIdentifier
429 writeModification.write(choicePath, choiceNode);
431 final ContainerNode con3Node = createCon3Node();
432 final YangInstanceIdentifier con3Path = YangInstanceIdentifier.of(odl)
434 writeModification.write(con3Path, con3Node);
436 final LeafSetNode<?> leafListNode = createLeafRefLeafListNode();
437 final YangInstanceIdentifier leafListPath = YangInstanceIdentifier.of(
438 odl).node(leafrefLeafList);
439 writeModification.write(leafListPath, leafListNode);
440 writeModification.ready();
442 final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
443 .prepare(writeModification);
445 LOG.debug("*************************");
446 LOG.debug("Before write2: ");
447 LOG.debug("*************************");
448 LOG.debug(inMemoryDataTree.toString());
450 boolean exception = false;
452 LeafRefValidatation.validate(writeContributorsCandidate,
454 } catch (final LeafRefDataValidationFailedException e) {
455 LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
456 assertEquals(6, e.getValidationsErrorsCount());
460 assertTrue(exception);
462 inMemoryDataTree.commit(writeContributorsCandidate);
464 LOG.debug("*************************");
465 LOG.debug("After write2: ");
466 LOG.debug("*************************");
467 LOG.debug(inMemoryDataTree.toString());
471 private static LeafSetNode<?> createLeafRefLeafListNode() {
473 final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafSetBuilder = Builders
475 leafSetBuilder.withNodeIdentifier(new NodeIdentifier(leafrefLeafList));
477 leafSetBuilder.addChild(createLeafSetEntry(leafrefLeafList, "k1"));
478 leafSetBuilder.addChild(createLeafSetEntry(leafrefLeafList, "k2"));
479 leafSetBuilder.addChild(createLeafSetEntry(leafrefLeafList, "k3"));
481 return leafSetBuilder.build();
484 private static ContainerNode createCon3Node() {
486 final CollectionNodeBuilder<MapEntryNode, MapNode> mapBuilder = Builders
488 mapBuilder.withNodeIdentifier(new NodeIdentifier(list3InChoice));
490 mapBuilder.addChild(createList3Entry("k1", "val1", "valA", "valX"));
491 mapBuilder.addChild(createList3Entry("k2", "val2", "valB", "valY"));
493 final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choiceBuilder = Builders
495 choiceBuilder.withNodeIdentifier(new NodeIdentifier(choiceInCon3));
497 choiceBuilder.addChild(mapBuilder.build());
499 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
501 containerBuilder.withNodeIdentifier(new NodeIdentifier(con3));
503 containerBuilder.addChild(choiceBuilder.build());
505 return containerBuilder.build();
508 private static MapEntryNode createList3Entry(final String kVal,
509 final String l3Val1, final String l3Val2, final String l3Val3) {
510 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
512 mapEntryBuilder.withNodeIdentifier(new NodeIdentifierWithPredicates(
513 list3InChoice, k, kVal));
515 final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafSetBuilder = Builders
517 leafSetBuilder.withNodeIdentifier(new NodeIdentifier(l3));
519 leafSetBuilder.addChild(createLeafSetEntry(l3, l3Val1));
520 leafSetBuilder.addChild(createLeafSetEntry(l3, l3Val2));
521 leafSetBuilder.addChild(createLeafSetEntry(l3, l3Val3));
523 mapEntryBuilder.addChild(ImmutableNodes.leafNode(k, kVal));
524 mapEntryBuilder.addChild(leafSetBuilder.build());
526 return mapEntryBuilder.build();
529 private static LeafSetEntryNode<Object> createLeafSetEntry(
530 final QName qname, final String val) {
531 final NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder = Builders
532 .leafSetEntryBuilder();
533 leafSetEntryBuilder.withNodeIdentifier(new NodeWithValue(qname, val));
534 leafSetEntryBuilder.withValue(val);
535 return leafSetEntryBuilder.build();
538 private static ChoiceNode createChoiceNode() {
540 final CollectionNodeBuilder<MapEntryNode, MapNode> listInChoiceBuilder = Builders
543 .withNodeIdentifier(new NodeIdentifier(listInChoice));
545 listInChoiceBuilder.addChild(createListInChoiceEntry("key1",
546 "leafref-in-choice value", "val1"));
547 listInChoiceBuilder.addChild(createListInChoiceEntry("key2",
548 "l1 value", "val2"));
549 listInChoiceBuilder.addChild(createListInChoiceEntry("key3",
550 "l1 value", "val3"));
552 final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choice2Builder = Builders
554 choice2Builder.withNodeIdentifier(new NodeIdentifier(ch2));
556 choice2Builder.addChild(listInChoiceBuilder.build());
558 final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choiceBuilder = Builders
560 choiceBuilder.withNodeIdentifier(new NodeIdentifier(ch1));
561 choiceBuilder.addChild(choice2Builder.build());
563 return choiceBuilder.build();
566 private static MapEntryNode createListInChoiceEntry(final String keyVal,
567 final String leafrefInChoiceVal,
568 final String leafrefInChoiceToChoiceVal) {
570 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
573 mapEntryBuilder.withNodeIdentifier(new NodeIdentifierWithPredicates(
574 listInChoice, listInChoiceKey, keyVal));
576 mapEntryBuilder.addChild(ImmutableNodes.leafNode(listInChoiceKey,
578 mapEntryBuilder.addChild(ImmutableNodes.leafNode(leafrefInChoice,
579 leafrefInChoiceVal));
580 mapEntryBuilder.addChild(ImmutableNodes.leafNode(
581 leafrefInChoiceToChoice, leafrefInChoiceToChoiceVal));
583 return mapEntryBuilder.build();
586 private static void delete() {
588 final YangInstanceIdentifier contributorPath = YangInstanceIdentifier
590 final DataTreeModification delete = inMemoryDataTree.takeSnapshot()
592 delete.delete(contributorPath);
595 final DataTreeCandidate deleteContributorsCanditate = inMemoryDataTree
598 LOG.debug("*************************");
599 LOG.debug("Before delete: ");
600 LOG.debug("*************************");
601 LOG.debug(inMemoryDataTree.toString());
603 boolean exception = false;
605 LeafRefValidatation.validate(deleteContributorsCanditate,
607 } catch (final LeafRefDataValidationFailedException e) {
608 LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
609 assertEquals(6, e.getValidationsErrorsCount());
613 assertTrue(exception);
615 inMemoryDataTree.commit(deleteContributorsCanditate);
617 LOG.debug("*************************");
618 LOG.debug("After delete: ");
619 LOG.debug("*************************");
620 LOG.debug(inMemoryDataTree.toString());
624 private static ContainerNode createContributorContainer(
625 final ContainerSchemaNode contributorContSchemaNode) {
627 final ListSchemaNode contributorListSchemaNode = (ListSchemaNode) contributorContSchemaNode
628 .getDataChildByName(contributor);
630 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
631 .containerBuilder(contributorContSchemaNode);
633 final MapNode contributorMap = createContributorList(contributorListSchemaNode);
634 contributorContainerBldr.addChild(contributorMap);
636 final ContainerNode contributorContainer = contributorContainerBldr
639 return contributorContainer;
643 private static MapNode createContributorList(
644 final ListSchemaNode contributorListSchemaNode) {
646 final CollectionNodeBuilder<MapEntryNode, MapNode> contributorMapBldr = Builders
647 .mapBuilder(contributorListSchemaNode);
649 final MapEntryNode contributorMapEntry1 = createContributorListEntry(
650 "Leader of Yangtools", "Yangtools Leader name", "Yangtools",
651 "Yangtools description ...", contributorListSchemaNode);
652 final MapEntryNode contributorMapEntry2 = createContributorListEntry(
653 "Leader of MD-SAL", "MD-SAL Leader name", "MD-SAL",
654 "MD-SAL description ...", contributorListSchemaNode);
655 final MapEntryNode contributorMapEntry3 = createContributorListEntry(
656 "Leader of Controller", "Controller Leader name", "Controller",
657 "Controller description ...", contributorListSchemaNode);
659 final MapEntryNode contributorMapEntry4 = createContributorListEntry(
660 "jdoe", "John Doe", "MD-SAL", "Yangtools description ...",
661 contributorListSchemaNode);
663 final MapEntryNode contributorMapEntry5 = createContributorListEntry(
664 "foo", "foo name", "Controller", "MD-SAL description ...",
665 contributorListSchemaNode);
667 final MapEntryNode contributorMapEntry6 = createContributorListEntry(
668 "bar", "bar name", "Yangtools", "Controller description ...",
669 contributorListSchemaNode);
671 final MapEntryNode contributorMapEntry7 = createContributorListEntry(
672 "baz", "baz name", "Unknown Project",
673 "Unknown Project description ...", contributorListSchemaNode);
675 final MapEntryNode contributorMapEntry8 = createContributorListEntry(
676 "pk", "pk name", "Unknown Project 2",
677 "Controller description ...", contributorListSchemaNode);
679 contributorMapBldr.addChild(contributorMapEntry1);
680 contributorMapBldr.addChild(contributorMapEntry2);
681 contributorMapBldr.addChild(contributorMapEntry3);
682 contributorMapBldr.addChild(contributorMapEntry4);
683 contributorMapBldr.addChild(contributorMapEntry5);
684 contributorMapBldr.addChild(contributorMapEntry6);
685 contributorMapBldr.addChild(contributorMapEntry7);
686 contributorMapBldr.addChild(contributorMapEntry8);
688 final MapNode contributorMap = contributorMapBldr.build();
690 return contributorMap;
694 private static MapEntryNode createContributorListEntry(
695 final String loginVal, final String contributorNameVal,
696 final String odlProjectNameVal, final String odlProjectDescVal,
697 final ListSchemaNode contributorListSchemaNode) {
699 final LeafNode<String> loginLeaf = ImmutableNodes.leafNode(login,
701 final LeafNode<String> contributorNameLeaf = ImmutableNodes.leafNode(
702 contributorName, contributorNameVal);
703 final LeafNode<String> odlProjectNameLeafRef = ImmutableNodes.leafNode(
704 odlProjectName, odlProjectNameVal);
705 final LeafNode<String> odlProjectDescLeafRef = ImmutableNodes.leafNode(
706 odlProjectDesc, odlProjectDescVal);
708 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> contributorMapEntryBldr = Builders
709 .mapEntryBuilder(contributorListSchemaNode);
711 contributorMapEntryBldr.addChild(loginLeaf);
712 contributorMapEntryBldr.addChild(contributorNameLeaf);
713 contributorMapEntryBldr.addChild(odlProjectNameLeafRef);
714 contributorMapEntryBldr.addChild(odlProjectDescLeafRef);
716 final MapEntryNode contributorMapEntry = contributorMapEntryBldr
719 return contributorMapEntry;
722 private static ContainerNode createOdlContainer(
723 final ContainerSchemaNode container) {
725 final ListSchemaNode projListSchemaNode = (ListSchemaNode) container
726 .getDataChildByName(project);
728 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> odlProjectContainerBldr = Builders
729 .containerBuilder(container);
731 final MapNode projectMap = createProjectList(projListSchemaNode);
732 odlProjectContainerBldr.addChild(projectMap);
734 final ContainerNode odlProjectContainer = odlProjectContainerBldr
737 return odlProjectContainer;
740 private static MapNode createProjectList(
741 final ListSchemaNode projListSchemaNode) {
743 final CollectionNodeBuilder<MapEntryNode, MapNode> projectMapBldr = Builders
744 .mapBuilder(projListSchemaNode);
746 final MapEntryNode projMapEntry1 = createProjectListEntry("Yangtools",
747 "Yangtools description ...", "Leader of Yangtools",
748 "Owner of Yangtools", projListSchemaNode);
749 final MapEntryNode projMapEntry2 = createProjectListEntry("MD-SAL",
750 "MD-SAL description ...", "Leader of MD-SAL",
751 "Owner of MD-SAL", projListSchemaNode);
752 final MapEntryNode projMapEntry3 = createProjectListEntry("Controller",
753 "Controller description ...", "Leader of Controller",
754 "Owner of Controller", projListSchemaNode);
756 projectMapBldr.addChild(projMapEntry1);
757 projectMapBldr.addChild(projMapEntry2);
758 projectMapBldr.addChild(projMapEntry3);
760 final MapNode projectMap = projectMapBldr.build();
765 private static MapEntryNode createProjectListEntry(final String nameVal,
766 final String descVal, final String leadVal, final String ownerVal,
767 final ListSchemaNode projListSchemaNode) {
769 final LeafNode<String> nameLeaf = ImmutableNodes
770 .leafNode(name, nameVal);
771 final LeafNode<String> descLeaf = ImmutableNodes
772 .leafNode(desc, descVal);
773 final LeafNode<String> leadLeafRef = ImmutableNodes.leafNode(lead,
775 final LeafNode<String> ownerLeafRef = ImmutableNodes.leafNode(owner,
778 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> projMapEntryBldr = Builders
779 .mapEntryBuilder(projListSchemaNode);
781 projMapEntryBldr.addChild(nameLeaf);
782 projMapEntryBldr.addChild(descLeaf);
783 projMapEntryBldr.addChild(leadLeafRef);
784 projMapEntryBldr.addChild(ownerLeafRef);
785 final MapEntryNode projMapEntry = projMapEntryBldr.build();
790 private static ContainerNode createBasicContributorContainer(
791 final ContainerSchemaNode contributorContSchemaNode) {
793 final ListSchemaNode contributorListSchemaNode = (ListSchemaNode) contributorContSchemaNode
794 .getDataChildByName(contributor);
796 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
797 .containerBuilder(contributorContSchemaNode);
799 final MapNode contributorMap = createBasicContributorList(contributorListSchemaNode);
800 contributorContainerBldr.addChild(contributorMap);
802 final ContainerNode contributorContainer = contributorContainerBldr
805 return contributorContainer;
809 private static MapNode createBasicContributorList(
810 final ListSchemaNode contributorListSchemaNode) {
812 final CollectionNodeBuilder<MapEntryNode, MapNode> contributorMapBldr = Builders
813 .mapBuilder(contributorListSchemaNode);
815 final MapEntryNode contributorMapEntry1 = createContributorListEntry(
816 "Leader of Yangtools", "Yangtools Leader name", "Yangtools",
817 "Yangtools description ...", contributorListSchemaNode);
818 final MapEntryNode contributorMapEntry2 = createContributorListEntry(
819 "Leader of MD-SAL", "MD-SAL Leader name", "MD-SAL",
820 "MD-SAL description ...", contributorListSchemaNode);
821 final MapEntryNode contributorMapEntry3 = createContributorListEntry(
822 "Leader of Controller", "Controller Leader name", "Controller",
823 "Controller description ...", contributorListSchemaNode);
825 contributorMapBldr.addChild(contributorMapEntry1);
826 contributorMapBldr.addChild(contributorMapEntry2);
827 contributorMapBldr.addChild(contributorMapEntry3);
829 final MapNode contributorMap = contributorMapBldr.build();
831 return contributorMap;