yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/leafref/context/DataTreeCandidateValidatorTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.yangtools.yang.data.impl.leafref.context;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12
  13 import java.io.FileNotFoundException;
  14 import java.net.URISyntaxException;
  15 import java.util.HashMap;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import org.apache.log4j.BasicConfigurator;
  19 import org.junit.BeforeClass;
  20 import org.junit.Test;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.common.QNameModule;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  27 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
  28 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  29 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  30 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  31 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  32 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  33 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  34 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
  35 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
  36 import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
  37 import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
  38 import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContext;
  39 import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefDataValidationFailedException;
  40 import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefValidatation;
  41 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  42 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  43 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
  44 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
  45 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
  46 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
  47 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
  48 import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
  49 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  50 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  51 import org.opendaylight.yangtools.yang.model.api.Module;
  52 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  53 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  54 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  55 import org.slf4j.Logger;
  56 import org.slf4j.LoggerFactory;
  57
  58 public class DataTreeCandidateValidatorTest {
  59
  60     private static SchemaContext context;
  61     private static Module valModule;
  62     private static QNameModule valModuleQname;
  63     private static LeafRefContext rootLeafRefContext;
  64     public static TipProducingDataTree inMemoryDataTree;
  65
  66     private static QName odl;
  67     private static QName project;
  68     private static QName name;
  69     private static QName desc;
  70     private static QName lead;
  71     private static QName owner;
  72     private static QName odlContributor;
  73     private static QName contributor;
  74     private static QName odlProjectName;
  75     private static QName odlProjectDesc;
  76     private static QName login;
  77     private static QName contributorName;
  78     private static QName l1;
  79     private static QName l2;
  80     private static QName con1;
  81     private static QName ch1;
  82     private static QName ch2;
  83     private static QName leafrefInChoice;
  84     private static QName listInChoice;
  85
  86     private static QName leafrefInChoiceToChoice;
  87     private static QName con3;
  88     private static QName list3InChoice;
  89     private static QName l3;
  90     private static QName choiceInCon3;
  91
  92     private static QName listInChoiceKey;
  93     private static QName k;
  94
  95     private static QName leafrefLeafList;
  96
  97     private static final Logger LOG = LoggerFactory.getLogger(DataTreeCandidateValidatorTest.class);
  98     private static final String NEW_LINE = System.getProperty("line.separator");
  99
 100     static {
 101         BasicConfigurator.configure();
 102     }
 103
 104     @BeforeClass
 105     public static void init() throws FileNotFoundException, ReactorException,
 106             URISyntaxException {
 107         initSchemaContext();
 108
 109         initLeafRefContext();
 110
 111         initQnames();
 112
 113         initDataTree();
 114
 115     }
 116
 117     private static void initSchemaContext() {
 118         context = YangParserTestUtils.parseYangResourceDirectory("/leafref-validation");
 119
 120         final Set<Module> modules = context.getModules();
 121         for (final Module module : modules) {
 122             if (module.getName().equals("leafref-validation")) {
 123                 valModule = module;
 124             }
 125         }
 126
 127         valModuleQname = valModule.getQNameModule();
 128     }
 129
 130     private static void initLeafRefContext() {
 131         rootLeafRefContext = LeafRefContext.create(context);
 132     }
 133
 134     private static void initQnames() {
 135         odl = QName.create(valModuleQname, "odl-project");
 136         project = QName.create(valModuleQname, "project");
 137         name = QName.create(valModuleQname, "name");
 138         desc = QName.create(valModuleQname, "desc");
 139         lead = QName.create(valModuleQname, "project-lead");
 140         owner = QName.create(valModuleQname, "project-owner");
 141
 142         odlContributor = QName.create(valModuleQname, "odl-contributor");
 143         contributor = QName.create(valModuleQname, "contributor");
 144         odlProjectName = QName.create(valModuleQname, "odl-project-name");
 145         login = QName.create(valModuleQname, "login");
 146         contributorName = QName.create(valModuleQname, "contributor-name");
 147
 148         con1 = QName.create(valModuleQname, "con1");
 149         l1 = QName.create(valModuleQname, "l1");
 150         l2 = QName.create(valModuleQname, "l2");
 151         odlProjectDesc = QName.create(valModuleQname, "odl-project-desc");
 152
 153         ch1 = QName.create(valModuleQname, "ch1");
 154         ch2 = QName.create(valModuleQname, "ch2");
 155         leafrefInChoice = QName.create(valModuleQname, "leafref-in-choice");
 156         listInChoice = QName.create(valModuleQname, "list-in-choice");
 157
 158         leafrefInChoiceToChoice = QName.create(valModuleQname,
 159                 "leafref-in-choice-to-choice");
 160         con3 = QName.create(valModuleQname, "con3");
 161         list3InChoice = QName.create(valModuleQname, "list3-in-choice");
 162         l3 = QName.create(valModuleQname, "l3");
 163         choiceInCon3 = QName.create(valModuleQname, "choice-in-con3");
 164
 165         listInChoiceKey = QName.create(valModuleQname, "list-in-choice-key");
 166         k = QName.create(valModuleQname, "k");
 167
 168         leafrefLeafList = QName.create(valModuleQname, "leafref-leaf-list");
 169
 170     }
 171
 172     private static void initDataTree() {
 173         inMemoryDataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
 174         inMemoryDataTree.setSchemaContext(context);
 175
 176         final DataTreeModification initialDataTreeModification = inMemoryDataTree
 177                 .takeSnapshot().newModification();
 178
 179         final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule
 180                 .getDataChildByName(odl);
 181
 182         final ContainerNode odlProjectContainer = createOdlContainer(odlProjContSchemaNode);
 183
 184         final YangInstanceIdentifier path = YangInstanceIdentifier.of(odl);
 185         initialDataTreeModification.write(path, odlProjectContainer);
 186         initialDataTreeModification.ready();
 187
 188         final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
 189                 .prepare(initialDataTreeModification);
 190         inMemoryDataTree.commit(writeContributorsCandidate);
 191
 192     }
 193
 194     @Test
 195     public void dataTreeCanditateValidationTest() {
 196         write();
 197
 198         write2();
 199
 200         delete();
 201
 202         writeContributors();
 203
 204         writeMapEntry();
 205
 206         writeIntoMapEntry();
 207     }
 208
 209     private static void writeContributors() {
 210
 211         final ContainerSchemaNode contributorContSchemaNode = (ContainerSchemaNode) valModule
 212                 .getDataChildByName(odlContributor);
 213
 214         final ContainerNode contributorContainer = createBasicContributorContainer(contributorContSchemaNode);
 215
 216         final YangInstanceIdentifier contributorPath = YangInstanceIdentifier
 217                 .of(odlContributor);
 218         final DataTreeModification writeModification = inMemoryDataTree
 219                 .takeSnapshot().newModification();
 220         writeModification.write(contributorPath, contributorContainer);
 221         writeModification.ready();
 222
 223         final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
 224                 .prepare(writeModification);
 225
 226         LOG.debug("*************************");
 227         LOG.debug("Before write of contributors: ");
 228         LOG.debug("*************************");
 229         LOG.debug(inMemoryDataTree.toString());
 230
 231         boolean exception = false;
 232         try {
 233             LeafRefValidatation.validate(writeContributorsCandidate,
 234                     rootLeafRefContext);
 235         } catch (final LeafRefDataValidationFailedException e) {
 236             LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
 237             assertEquals(3, e.getValidationsErrorsCount());
 238             exception = true;
 239         }
 240
 241         inMemoryDataTree.commit(writeContributorsCandidate);
 242
 243         LOG.debug("*************************");
 244         LOG.debug("After write of contributors: ");
 245         LOG.debug("*************************");
 246         LOG.debug(inMemoryDataTree.toString());
 247
 248         assertTrue(exception);
 249
 250     }
 251
 252     private static void writeIntoMapEntry() {
 253
 254         final Map<QName, Object> keys = new HashMap<>();
 255         keys.put(name, "New Project");
 256         final NodeIdentifierWithPredicates mapEntryPath = new NodeIdentifierWithPredicates(
 257                 project, keys);
 258
 259         final YangInstanceIdentifier leaderPath = YangInstanceIdentifier
 260                 .of(odl).node(project).node(mapEntryPath).node(lead);
 261
 262         final LeafNode<String> leader = ImmutableNodes.leafNode(lead,
 263                 "Updated leader");
 264
 265         final DataTreeModification writeModification = inMemoryDataTree
 266                 .takeSnapshot().newModification();
 267         writeModification.write(leaderPath, leader);
 268         writeModification.ready();
 269
 270         final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
 271                 .prepare(writeModification);
 272
 273         LOG.debug("*************************");
 274         LOG.debug("Before write into map entry (update of leader name): ");
 275         LOG.debug("*************************");
 276         LOG.debug(inMemoryDataTree.toString());
 277
 278         boolean exception = false;
 279         try {
 280             LeafRefValidatation.validate(writeContributorsCandidate,
 281                     rootLeafRefContext);
 282         } catch (final LeafRefDataValidationFailedException e) {
 283             LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
 284             assertEquals(1, e.getValidationsErrorsCount());
 285             exception = true;
 286         }
 287
 288         inMemoryDataTree.commit(writeContributorsCandidate);
 289
 290         LOG.debug("*************************");
 291         LOG.debug("After write into map entry (update of leader name): ");
 292         LOG.debug("*************************");
 293         LOG.debug(inMemoryDataTree.toString());
 294
 295         assertTrue(exception);
 296
 297     }
 298
 299     private static void writeMapEntry() {
 300
 301         final Map<QName, Object> keys = new HashMap<>();
 302         keys.put(name, "New Project");
 303         final NodeIdentifierWithPredicates mapEntryPath = new NodeIdentifierWithPredicates(
 304                 project, keys);
 305
 306         final YangInstanceIdentifier newOdlProjectMapEntryPath = YangInstanceIdentifier
 307                 .of(odl).node(project).node(mapEntryPath);
 308
 309         final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule
 310                 .getDataChildByName(odl);
 311         final ListSchemaNode projListSchemaNode = (ListSchemaNode) odlProjContSchemaNode
 312                 .getDataChildByName(project);
 313         final MapEntryNode newProjectMapEntry = createProjectListEntry(
 314                 "New Project", "New Project description ...",
 315                 "Leader of New Project", "Owner of New Project",
 316                 projListSchemaNode);
 317
 318         final DataTreeModification writeModification = inMemoryDataTree
 319                 .takeSnapshot().newModification();
 320         writeModification.write(newOdlProjectMapEntryPath, newProjectMapEntry);
 321         writeModification.ready();
 322
 323         final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
 324                 .prepare(writeModification);
 325
 326         LOG.debug("*************************");
 327         LOG.debug("Before map entry write: ");
 328         LOG.debug("*************************");
 329         LOG.debug(inMemoryDataTree.toString());
 330
 331         boolean exception = false;
 332         try {
 333             LeafRefValidatation.validate(writeContributorsCandidate,
 334                     rootLeafRefContext);
 335         } catch (final LeafRefDataValidationFailedException e) {
 336             LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
 337             assertEquals(2, e.getValidationsErrorsCount());
 338             exception = true;
 339         }
 340
 341         inMemoryDataTree.commit(writeContributorsCandidate);
 342
 343         LOG.debug("*************************");
 344         LOG.debug("After map entry write: ");
 345         LOG.debug("*************************");
 346         LOG.debug(inMemoryDataTree.toString());
 347
 348         assertTrue(exception);
 349
 350     }
 351
 352     private static void write() {
 353
 354         final ContainerSchemaNode contributorContSchemaNode = (ContainerSchemaNode) valModule
 355                 .getDataChildByName(odlContributor);
 356
 357         final ContainerNode contributorContainer = createContributorContainer(contributorContSchemaNode);
 358
 359         final YangInstanceIdentifier contributorPath = YangInstanceIdentifier
 360                 .of(odlContributor);
 361         final DataTreeModification writeModification = inMemoryDataTree
 362                 .takeSnapshot().newModification();
 363         writeModification.write(contributorPath, contributorContainer);
 364
 365         writeModification.write(YangInstanceIdentifier.of(l1),
 366                 ImmutableNodes.leafNode(l1, "Leafref l1 under the root"));
 367         writeModification
 368                 .write(YangInstanceIdentifier.of(l2), ImmutableNodes.leafNode(
 369                         l2, "Leafref target l2 under the root"));
 370
 371         writeModification.ready();
 372         final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
 373                 .prepare(writeModification);
 374
 375         LOG.debug("*************************");
 376         LOG.debug("Before write: ");
 377         LOG.debug("*************************");
 378         LOG.debug(inMemoryDataTree.toString());
 379
 380         boolean exception = false;
 381         try {
 382             LeafRefValidatation.validate(writeContributorsCandidate,
 383                     rootLeafRefContext);
 384         } catch (final LeafRefDataValidationFailedException e) {
 385             LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
 386             assertEquals(12, e.getValidationsErrorsCount());
 387             exception = true;
 388         }
 389
 390         inMemoryDataTree.commit(writeContributorsCandidate);
 391
 392         LOG.debug("*************************");
 393         LOG.debug("After write: ");
 394         LOG.debug("*************************");
 395         LOG.debug(inMemoryDataTree.toString());
 396
 397         assertTrue(exception);
 398     }
 399
 400     private static void write2() {
 401
 402         final ContainerSchemaNode odlCon = (ContainerSchemaNode) valModule
 403                 .getDataChildByName(odl);
 404         final ContainerSchemaNode con1Con = (ContainerSchemaNode) odlCon
 405                 .getDataChildByName(con1);
 406         final LeafNode<String> l1Leaf = ImmutableNodes.leafNode(l1, "l1 value");
 407         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
 408                 .containerBuilder(con1Con);
 409         containerBuilder.addChild(l1Leaf);
 410         final ContainerNode con1Node = containerBuilder.build();
 411
 412         final YangInstanceIdentifier con1Path = YangInstanceIdentifier.of(odl)
 413                 .node(con1);
 414         final DataTreeModification writeModification = inMemoryDataTree
 415                 .takeSnapshot().newModification();
 416         writeModification.write(con1Path, con1Node);
 417
 418         final ChoiceNode choiceNode = createChoiceNode();
 419         final YangInstanceIdentifier choicePath = YangInstanceIdentifier
 420                 .of(odl).node(ch1);
 421         writeModification.write(choicePath, choiceNode);
 422
 423         final ContainerNode con3Node = createCon3Node();
 424         final YangInstanceIdentifier con3Path = YangInstanceIdentifier.of(odl)
 425                 .node(con3);
 426         writeModification.write(con3Path, con3Node);
 427
 428         final LeafSetNode<?> leafListNode = createLeafRefLeafListNode();
 429         final YangInstanceIdentifier leafListPath = YangInstanceIdentifier.of(
 430                 odl).node(leafrefLeafList);
 431         writeModification.write(leafListPath, leafListNode);
 432         writeModification.ready();
 433
 434         final DataTreeCandidate writeContributorsCandidate = inMemoryDataTree
 435                 .prepare(writeModification);
 436
 437         LOG.debug("*************************");
 438         LOG.debug("Before write2: ");
 439         LOG.debug("*************************");
 440         LOG.debug(inMemoryDataTree.toString());
 441
 442         boolean exception = false;
 443         try {
 444             LeafRefValidatation.validate(writeContributorsCandidate,
 445                     rootLeafRefContext);
 446         } catch (final LeafRefDataValidationFailedException e) {
 447             LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
 448             assertEquals(6, e.getValidationsErrorsCount());
 449             exception = true;
 450         }
 451
 452         assertTrue(exception);
 453
 454         inMemoryDataTree.commit(writeContributorsCandidate);
 455
 456         LOG.debug("*************************");
 457         LOG.debug("After write2: ");
 458         LOG.debug("*************************");
 459         LOG.debug(inMemoryDataTree.toString());
 460
 461     }
 462
 463     private static LeafSetNode<?> createLeafRefLeafListNode() {
 464
 465         final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafSetBuilder = Builders
 466                 .leafSetBuilder();
 467         leafSetBuilder.withNodeIdentifier(new NodeIdentifier(leafrefLeafList));
 468
 469         leafSetBuilder.addChild(createLeafSetEntry(leafrefLeafList, "k1"));
 470         leafSetBuilder.addChild(createLeafSetEntry(leafrefLeafList, "k2"));
 471         leafSetBuilder.addChild(createLeafSetEntry(leafrefLeafList, "k3"));
 472
 473         return leafSetBuilder.build();
 474     }
 475
 476     private static ContainerNode createCon3Node() {
 477
 478         final CollectionNodeBuilder<MapEntryNode, MapNode> mapBuilder = Builders
 479                 .mapBuilder();
 480         mapBuilder.withNodeIdentifier(new NodeIdentifier(list3InChoice));
 481
 482         mapBuilder.addChild(createList3Entry("k1", "val1", "valA", "valX"));
 483         mapBuilder.addChild(createList3Entry("k2", "val2", "valB", "valY"));
 484
 485         final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choiceBuilder = Builders
 486                 .choiceBuilder();
 487         choiceBuilder.withNodeIdentifier(new NodeIdentifier(choiceInCon3));
 488
 489         choiceBuilder.addChild(mapBuilder.build());
 490
 491         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
 492                 .containerBuilder();
 493         containerBuilder.withNodeIdentifier(new NodeIdentifier(con3));
 494
 495         containerBuilder.addChild(choiceBuilder.build());
 496
 497         return containerBuilder.build();
 498     }
 499
 500     private static MapEntryNode createList3Entry(final String kVal,
 501             final String l3Val1, final String l3Val2, final String l3Val3) {
 502         final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
 503                 .mapEntryBuilder();
 504         mapEntryBuilder.withNodeIdentifier(new NodeIdentifierWithPredicates(
 505                 list3InChoice, k, kVal));
 506
 507         final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafSetBuilder = Builders
 508                 .leafSetBuilder();
 509         leafSetBuilder.withNodeIdentifier(new NodeIdentifier(l3));
 510
 511         leafSetBuilder.addChild(createLeafSetEntry(l3, l3Val1));
 512         leafSetBuilder.addChild(createLeafSetEntry(l3, l3Val2));
 513         leafSetBuilder.addChild(createLeafSetEntry(l3, l3Val3));
 514
 515         mapEntryBuilder.addChild(ImmutableNodes.leafNode(k, kVal));
 516         mapEntryBuilder.addChild(leafSetBuilder.build());
 517
 518         return mapEntryBuilder.build();
 519     }
 520
 521     private static LeafSetEntryNode<Object> createLeafSetEntry(
 522             final QName qname, final String val) {
 523         final NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder = Builders
 524                 .leafSetEntryBuilder();
 525         leafSetEntryBuilder.withNodeIdentifier(new NodeWithValue<>(qname, val));
 526         leafSetEntryBuilder.withValue(val);
 527         return leafSetEntryBuilder.build();
 528     }
 529
 530     private static ChoiceNode createChoiceNode() {
 531
 532         final CollectionNodeBuilder<MapEntryNode, MapNode> listInChoiceBuilder = Builders
 533                 .mapBuilder();
 534         listInChoiceBuilder
 535                 .withNodeIdentifier(new NodeIdentifier(listInChoice));
 536
 537         listInChoiceBuilder.addChild(createListInChoiceEntry("key1",
 538                 "leafref-in-choice value", "val1"));
 539         listInChoiceBuilder.addChild(createListInChoiceEntry("key2",
 540                 "l1 value", "val2"));
 541         listInChoiceBuilder.addChild(createListInChoiceEntry("key3",
 542                 "l1 value", "val3"));
 543
 544         final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choice2Builder = Builders
 545                 .choiceBuilder();
 546         choice2Builder.withNodeIdentifier(new NodeIdentifier(ch2));
 547
 548         choice2Builder.addChild(listInChoiceBuilder.build());
 549
 550         final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choiceBuilder = Builders
 551                 .choiceBuilder();
 552         choiceBuilder.withNodeIdentifier(new NodeIdentifier(ch1));
 553         choiceBuilder.addChild(choice2Builder.build());
 554
 555         return choiceBuilder.build();
 556     }
 557
 558     private static MapEntryNode createListInChoiceEntry(final String keyVal,
 559             final String leafrefInChoiceVal,
 560             final String leafrefInChoiceToChoiceVal) {
 561
 562         final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
 563                 .mapEntryBuilder();
 564
 565         mapEntryBuilder.withNodeIdentifier(new NodeIdentifierWithPredicates(
 566                 listInChoice, listInChoiceKey, keyVal));
 567
 568         mapEntryBuilder.addChild(ImmutableNodes.leafNode(listInChoiceKey,
 569                 keyVal));
 570         mapEntryBuilder.addChild(ImmutableNodes.leafNode(leafrefInChoice,
 571                 leafrefInChoiceVal));
 572         mapEntryBuilder.addChild(ImmutableNodes.leafNode(
 573                 leafrefInChoiceToChoice, leafrefInChoiceToChoiceVal));
 574
 575         return mapEntryBuilder.build();
 576     }
 577
 578     private static void delete() {
 579
 580         final YangInstanceIdentifier contributorPath = YangInstanceIdentifier
 581                 .of(odlContributor);
 582         final DataTreeModification delete = inMemoryDataTree.takeSnapshot()
 583                 .newModification();
 584         delete.delete(contributorPath);
 585         delete.ready();
 586
 587         final DataTreeCandidate deleteContributorsCanditate = inMemoryDataTree
 588                 .prepare(delete);
 589
 590         LOG.debug("*************************");
 591         LOG.debug("Before delete: ");
 592         LOG.debug("*************************");
 593         LOG.debug(inMemoryDataTree.toString());
 594
 595         boolean exception = false;
 596         try {
 597             LeafRefValidatation.validate(deleteContributorsCanditate,
 598                     rootLeafRefContext);
 599         } catch (final LeafRefDataValidationFailedException e) {
 600             LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
 601             assertEquals(6, e.getValidationsErrorsCount());
 602             exception = true;
 603         }
 604
 605         assertTrue(exception);
 606
 607         inMemoryDataTree.commit(deleteContributorsCanditate);
 608
 609         LOG.debug("*************************");
 610         LOG.debug("After delete: ");
 611         LOG.debug("*************************");
 612         LOG.debug(inMemoryDataTree.toString());
 613
 614     }
 615
 616     private static ContainerNode createContributorContainer(
 617             final ContainerSchemaNode contributorContSchemaNode) {
 618
 619         final ListSchemaNode contributorListSchemaNode = (ListSchemaNode) contributorContSchemaNode
 620                 .getDataChildByName(contributor);
 621
 622         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
 623                 .containerBuilder(contributorContSchemaNode);
 624
 625         final MapNode contributorMap = createContributorList(contributorListSchemaNode);
 626         contributorContainerBldr.addChild(contributorMap);
 627
 628         final ContainerNode contributorContainer = contributorContainerBldr
 629                 .build();
 630
 631         return contributorContainer;
 632
 633     }
 634
 635     private static MapNode createContributorList(
 636             final ListSchemaNode contributorListSchemaNode) {
 637
 638         final CollectionNodeBuilder<MapEntryNode, MapNode> contributorMapBldr = Builders
 639                 .mapBuilder(contributorListSchemaNode);
 640
 641         final MapEntryNode contributorMapEntry1 = createContributorListEntry(
 642                 "Leader of Yangtools", "Yangtools Leader name", "Yangtools",
 643                 "Yangtools description ...", contributorListSchemaNode);
 644         final MapEntryNode contributorMapEntry2 = createContributorListEntry(
 645                 "Leader of MD-SAL", "MD-SAL Leader name", "MD-SAL",
 646                 "MD-SAL description ...", contributorListSchemaNode);
 647         final MapEntryNode contributorMapEntry3 = createContributorListEntry(
 648                 "Leader of Controller", "Controller Leader name", "Controller",
 649                 "Controller description ...", contributorListSchemaNode);
 650
 651         final MapEntryNode contributorMapEntry4 = createContributorListEntry(
 652                 "jdoe", "John Doe", "MD-SAL", "Yangtools description ...",
 653                 contributorListSchemaNode);
 654
 655         final MapEntryNode contributorMapEntry5 = createContributorListEntry(
 656                 "foo", "foo name", "Controller", "MD-SAL description ...",
 657                 contributorListSchemaNode);
 658
 659         final MapEntryNode contributorMapEntry6 = createContributorListEntry(
 660                 "bar", "bar name", "Yangtools", "Controller description ...",
 661                 contributorListSchemaNode);
 662
 663         final MapEntryNode contributorMapEntry7 = createContributorListEntry(
 664                 "baz", "baz name", "Unknown Project",
 665                 "Unknown Project description ...", contributorListSchemaNode);
 666
 667         final MapEntryNode contributorMapEntry8 = createContributorListEntry(
 668                 "pk", "pk name", "Unknown Project 2",
 669                 "Controller description ...", contributorListSchemaNode);
 670
 671         contributorMapBldr.addChild(contributorMapEntry1);
 672         contributorMapBldr.addChild(contributorMapEntry2);
 673         contributorMapBldr.addChild(contributorMapEntry3);
 674         contributorMapBldr.addChild(contributorMapEntry4);
 675         contributorMapBldr.addChild(contributorMapEntry5);
 676         contributorMapBldr.addChild(contributorMapEntry6);
 677         contributorMapBldr.addChild(contributorMapEntry7);
 678         contributorMapBldr.addChild(contributorMapEntry8);
 679
 680         final MapNode contributorMap = contributorMapBldr.build();
 681
 682         return contributorMap;
 683
 684     }
 685
 686     private static MapEntryNode createContributorListEntry(
 687             final String loginVal, final String contributorNameVal,
 688             final String odlProjectNameVal, final String odlProjectDescVal,
 689             final ListSchemaNode contributorListSchemaNode) {
 690
 691         final LeafNode<String> loginLeaf = ImmutableNodes.leafNode(login,
 692                 loginVal);
 693         final LeafNode<String> contributorNameLeaf = ImmutableNodes.leafNode(
 694                 contributorName, contributorNameVal);
 695         final LeafNode<String> odlProjectNameLeafRef = ImmutableNodes.leafNode(
 696                 odlProjectName, odlProjectNameVal);
 697         final LeafNode<String> odlProjectDescLeafRef = ImmutableNodes.leafNode(
 698                 odlProjectDesc, odlProjectDescVal);
 699
 700         final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> contributorMapEntryBldr = Builders
 701                 .mapEntryBuilder(contributorListSchemaNode);
 702
 703         contributorMapEntryBldr.addChild(loginLeaf);
 704         contributorMapEntryBldr.addChild(contributorNameLeaf);
 705         contributorMapEntryBldr.addChild(odlProjectNameLeafRef);
 706         contributorMapEntryBldr.addChild(odlProjectDescLeafRef);
 707
 708         final MapEntryNode contributorMapEntry = contributorMapEntryBldr
 709                 .build();
 710
 711         return contributorMapEntry;
 712     }
 713
 714     private static ContainerNode createOdlContainer(
 715             final ContainerSchemaNode container) {
 716
 717         final ListSchemaNode projListSchemaNode = (ListSchemaNode) container
 718                 .getDataChildByName(project);
 719
 720         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> odlProjectContainerBldr = Builders
 721                 .containerBuilder(container);
 722
 723         final MapNode projectMap = createProjectList(projListSchemaNode);
 724         odlProjectContainerBldr.addChild(projectMap);
 725
 726         final ContainerNode odlProjectContainer = odlProjectContainerBldr
 727                 .build();
 728
 729         return odlProjectContainer;
 730     }
 731
 732     private static MapNode createProjectList(
 733             final ListSchemaNode projListSchemaNode) {
 734
 735         final CollectionNodeBuilder<MapEntryNode, MapNode> projectMapBldr = Builders
 736                 .mapBuilder(projListSchemaNode);
 737
 738         final MapEntryNode projMapEntry1 = createProjectListEntry("Yangtools",
 739                 "Yangtools description ...", "Leader of Yangtools",
 740                 "Owner of Yangtools", projListSchemaNode);
 741         final MapEntryNode projMapEntry2 = createProjectListEntry("MD-SAL",
 742                 "MD-SAL description ...", "Leader of MD-SAL",
 743                 "Owner of MD-SAL", projListSchemaNode);
 744         final MapEntryNode projMapEntry3 = createProjectListEntry("Controller",
 745                 "Controller description ...", "Leader of Controller",
 746                 "Owner of Controller", projListSchemaNode);
 747
 748         projectMapBldr.addChild(projMapEntry1);
 749         projectMapBldr.addChild(projMapEntry2);
 750         projectMapBldr.addChild(projMapEntry3);
 751
 752         final MapNode projectMap = projectMapBldr.build();
 753
 754         return projectMap;
 755     }
 756
 757     private static MapEntryNode createProjectListEntry(final String nameVal,
 758             final String descVal, final String leadVal, final String ownerVal,
 759             final ListSchemaNode projListSchemaNode) {
 760
 761         final LeafNode<String> nameLeaf = ImmutableNodes
 762                 .leafNode(name, nameVal);
 763         final LeafNode<String> descLeaf = ImmutableNodes
 764                 .leafNode(desc, descVal);
 765         final LeafNode<String> leadLeafRef = ImmutableNodes.leafNode(lead,
 766                 leadVal);
 767         final LeafNode<String> ownerLeafRef = ImmutableNodes.leafNode(owner,
 768                 ownerVal);
 769
 770         final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> projMapEntryBldr = Builders
 771                 .mapEntryBuilder(projListSchemaNode);
 772
 773         projMapEntryBldr.addChild(nameLeaf);
 774         projMapEntryBldr.addChild(descLeaf);
 775         projMapEntryBldr.addChild(leadLeafRef);
 776         projMapEntryBldr.addChild(ownerLeafRef);
 777         final MapEntryNode projMapEntry = projMapEntryBldr.build();
 778
 779         return projMapEntry;
 780     }
 781
 782     private static ContainerNode createBasicContributorContainer(
 783             final ContainerSchemaNode contributorContSchemaNode) {
 784
 785         final ListSchemaNode contributorListSchemaNode = (ListSchemaNode) contributorContSchemaNode
 786                 .getDataChildByName(contributor);
 787
 788         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
 789                 .containerBuilder(contributorContSchemaNode);
 790
 791         final MapNode contributorMap = createBasicContributorList(contributorListSchemaNode);
 792         contributorContainerBldr.addChild(contributorMap);
 793
 794         final ContainerNode contributorContainer = contributorContainerBldr
 795                 .build();
 796
 797         return contributorContainer;
 798
 799     }
 800
 801     private static MapNode createBasicContributorList(
 802             final ListSchemaNode contributorListSchemaNode) {
 803
 804         final CollectionNodeBuilder<MapEntryNode, MapNode> contributorMapBldr = Builders
 805                 .mapBuilder(contributorListSchemaNode);
 806
 807         final MapEntryNode contributorMapEntry1 = createContributorListEntry(
 808                 "Leader of Yangtools", "Yangtools Leader name", "Yangtools",
 809                 "Yangtools description ...", contributorListSchemaNode);
 810         final MapEntryNode contributorMapEntry2 = createContributorListEntry(
 811                 "Leader of MD-SAL", "MD-SAL Leader name", "MD-SAL",
 812                 "MD-SAL description ...", contributorListSchemaNode);
 813         final MapEntryNode contributorMapEntry3 = createContributorListEntry(
 814                 "Leader of Controller", "Controller Leader name", "Controller",
 815                 "Controller description ...", contributorListSchemaNode);
 816
 817         contributorMapBldr.addChild(contributorMapEntry1);
 818         contributorMapBldr.addChild(contributorMapEntry2);
 819         contributorMapBldr.addChild(contributorMapEntry3);
 820
 821         final MapNode contributorMap = contributorMapBldr.build();
 822
 823         return contributorMap;
 824     }
 825 }