yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/builder/impl/CopyUtilsTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
   3  * This program and the accompanying materials are made available under the
   4  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   5  * and is available at http://www.eclipse.org/legal/epl-v10.html
   6  */
   7 package org.opendaylight.yangtools.yang.parser.builder.impl;
   8
   9 import static org.junit.Assert.assertEquals;
  10 import static org.junit.Assert.assertFalse;
  11 import static org.junit.Assert.assertNotEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import java.util.List;
  14 import org.junit.Test;
  15 import org.opendaylight.yangtools.yang.common.QName;
  16 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  17 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  18 import org.opendaylight.yangtools.yang.model.api.Status;
  19 import org.opendaylight.yangtools.yang.model.util.Uint16;
  20 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  21 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
  22 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
  23 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  27 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  28 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  29 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  30
  31 /**
  32  * Test suite for increasing of test coverage of CopyUtils implementation.
  33  *
  34  * @see org.opendaylight.yangtools.yang.parser.builder.impl.CopyUtils
  35  *
  36  * @author Lukas Sedlak <lsedlak@cisco.com>
  37  */
  38 public class CopyUtilsTest extends AbstractBuilderTest {
  39
  40     @Test(expected = YangParseException.class)
  41     public void testCopyOfUnknownTypeOfDataSchemaNode() {
  42         final String leafLocalName = "leaf-to-refine";
  43         final QName leafName = QName.create(module.getNamespace(), module.getRevision(), leafLocalName);
  44         final SchemaPath leafPath = SchemaPath.create(true, leafName);
  45         final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(module.getModuleName(), 22, leafName, leafPath);
  46
  47         CopyUtils.copy(new InvalidDataSchemaNodeBuilder(), leafBuilder, false);
  48     }
  49
  50     @Test
  51     public void testCopyAnyxmlWithAnyxmlOriginalNodeAndUnknownNodes() {
  52         final String parentAnyxmlLocalName = "original-anyxml";
  53         final QName parentAnyxmlName = QName.create(module.getNamespace(), module.getRevision(), parentAnyxmlLocalName);
  54         final SchemaPath parentAnyxmlPath = SchemaPath.create(true, parentAnyxmlName);
  55         final AnyXmlBuilder parentAnyXmlBuilder = new AnyXmlBuilder(module.getModuleName(), 22, parentAnyxmlName, parentAnyxmlPath);
  56
  57         final String anyxmlLocalName = "anyxml";
  58         final QName anyxmlName = QName.create(module.getNamespace(), module.getRevision(), anyxmlLocalName);
  59         final SchemaPath anyxmlPath = SchemaPath.create(true, anyxmlName);
  60         final AnyXmlBuilder anyXmlBuilder = new AnyXmlBuilder(module.getModuleName(), 22, anyxmlName, anyxmlPath);
  61
  62         anyXmlBuilder.setOriginal(parentAnyXmlBuilder);
  63
  64         final UnknownSchemaNodeBuilder unknownSchemaNodeBuilder = provideUnknownNodeBuilder(anyxmlName);
  65         anyXmlBuilder.addUnknownNodeBuilder(unknownSchemaNodeBuilder);
  66
  67         final AnyXmlBuilder copy = (AnyXmlBuilder) CopyUtils.copy(anyXmlBuilder, anyXmlBuilder, false);
  68         assertFalse(copy.getUnknownNodes().isEmpty());
  69         assertNotNull(copy.getOriginal());
  70         assertEquals(copy.getOriginal(), parentAnyXmlBuilder);
  71     }
  72
  73     @Test
  74     public void testCopyChoiceBuilderWithUnknownNodesAndAugmentation() {
  75         final String originalChoiceLocalName = "original-choice-to-copy";
  76         final ChoiceBuilder originalChoiceBuilder = provideChoiceBuilder(originalChoiceLocalName);
  77
  78         final String choiceLocalName = "choice-to-copy";
  79         final ChoiceBuilder choiceBuilder = provideChoiceBuilder(choiceLocalName);
  80         choiceBuilder.setOriginal(originalChoiceBuilder);
  81
  82         final UnknownSchemaNodeBuilder unknownSchemaNodeBuilder = provideUnknownNodeBuilder(choiceBuilder.getQName());
  83         final SchemaPath augPath = SchemaPath.create(true, choiceBuilder.getQName());
  84
  85         final AugmentationSchemaBuilder augBuilder = new AugmentationSchemaBuilderImpl(module.getModuleName(), 22,
  86             "/imaginary/path", augPath, 0);
  87
  88         final UsesNodeBuilder usesNodeBuilder = provideUsesNodeBuilder("test-grouping-use");
  89             augBuilder.addUsesNode(usesNodeBuilder);
  90         augBuilder.addUnknownNodeBuilder(unknownSchemaNodeBuilder);
  91
  92         choiceBuilder.addUnknownNodeBuilder(unknownSchemaNodeBuilder);
  93         choiceBuilder.addAugmentation(augBuilder);
  94
  95         final ChoiceBuilder copy = (ChoiceBuilder)CopyUtils.copy(choiceBuilder, module, false);
  96         List<AugmentationSchemaBuilder> augmentations = copy.getAugmentationBuilders();
  97
  98         assertFalse(copy.getUnknownNodes().isEmpty());
  99
 100         final UnknownSchemaNodeBuilder copyUnknownNode = copy.getUnknownNodes().get(0);
 101         assertEquals(copyUnknownNode, unknownSchemaNodeBuilder);
 102
 103         assertFalse(augmentations.isEmpty());
 104         final AugmentationSchemaBuilder copyAugBuilder = augmentations.get(0);
 105
 106         assertEquals(copyAugBuilder, augBuilder);
 107         assertEquals(copyAugBuilder.getUnknownNodes().get(0), augBuilder.getUnknownNodes().get(0));
 108         assertNotEquals(copyAugBuilder.getUsesNodeBuilders().get(0), augBuilder.getUsesNodeBuilders().get(0));
 109     }
 110
 111     @Test
 112     public void testCopyChoiceCaseBuilder() {
 113         final String originalChoiceCaseLocalName = "original-choice-case";
 114         final QName originalChoiceCaseQName = QName.create(module.getNamespace(), module.getRevision(),
 115             originalChoiceCaseLocalName);
 116         final SchemaPath originalChoiceCasePath = SchemaPath.create(true, originalChoiceCaseQName);
 117         final ChoiceCaseBuilder originalChoiceCaseBuilder = new ChoiceCaseBuilder(module.getModuleName(), 10,
 118             originalChoiceCaseQName, originalChoiceCasePath);
 119
 120         final String choiceCaseLocalName = "test-choice-case";
 121         final QName choiceCaseQName = QName.create(module.getNamespace(), module.getRevision(), choiceCaseLocalName);
 122         final SchemaPath choiceCasePath = SchemaPath.create(true, choiceCaseQName);
 123         final ChoiceCaseBuilder choiceCaseBuilder = new ChoiceCaseBuilder(module.getModuleName(), 10, choiceCaseQName,
 124             choiceCasePath);
 125
 126         choiceCaseBuilder.setOriginal(originalChoiceCaseBuilder);
 127
 128         final UsesNodeBuilder usesNodeBuilder = provideUsesNodeBuilder("test-grouping-use");
 129
 130         UnknownSchemaNodeBuilder unknownSchemaNodeBuilder = provideUnknownNodeBuilder(choiceCaseQName);
 131
 132         choiceCaseBuilder.addUsesNode(usesNodeBuilder);
 133         choiceCaseBuilder.addUnknownNodeBuilder(unknownSchemaNodeBuilder);
 134
 135         ChoiceCaseBuilder copy = (ChoiceCaseBuilder) CopyUtils.copy(choiceCaseBuilder, module, true);
 136
 137         assertNotNull(copy);
 138         assertEquals(copy.getUnknownNodes().get(0), choiceCaseBuilder.getUnknownNodes().get(0));
 139         assertFalse(copy.getUsesNodeBuilders().isEmpty());
 140         assertNotEquals(copy.getUsesNodeBuilders().get(0), choiceCaseBuilder.getUsesNodeBuilders().get(0));
 141     }
 142
 143     @Test(expected = YangParseException.class)
 144     public void testAddGroupingIntoChoiceCaseBuilder() {
 145         final String choiceCaseLocalName = "test-choice-case";
 146         final QName choiceCaseQName = QName.create(module.getNamespace(), module.getRevision(), choiceCaseLocalName);
 147         final SchemaPath choiceCasePath = SchemaPath.create(true, choiceCaseQName);
 148         final ChoiceCaseBuilder choiceCaseBuilder = new ChoiceCaseBuilder(module.getModuleName(), 10, choiceCaseQName,
 149             choiceCasePath);
 150
 151         final String groupLocalName = "test-group";
 152         final QName testGroup = QName.create(module.getNamespace(), module.getRevision(), groupLocalName);
 153         final SchemaPath groupPath = SchemaPath.create(true, choiceCaseQName, testGroup);
 154         final GroupingBuilder grouping = module.addGrouping(12, testGroup, groupPath);
 155         choiceCaseBuilder.addGrouping(grouping);
 156     }
 157
 158     @Test
 159     public void testCopyContainerSchemaNodeBuilder() {
 160         final ContainerSchemaNodeBuilder containerBuilder = provideContainerBuilder("parent-container");
 161
 162         final String groupLocalName = "test-group";
 163         final GroupingBuilder grouping = provideNestedGroupingDefinition(containerBuilder.getQName(), groupLocalName);
 164
 165         final String typedefLocalName = "test-type-definition";
 166         final TypeDefinitionBuilder typedefBuilder = provideNestedTypedef(containerBuilder.getQName(), typedefLocalName);
 167
 168         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder(containerBuilder.getQName());
 169
 170         containerBuilder.addGrouping(grouping);
 171         containerBuilder.addTypedef(typedefBuilder);
 172         containerBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 173
 174         final ContainerSchemaNodeBuilder copy = (ContainerSchemaNodeBuilder) CopyUtils.copy(containerBuilder, module, true);
 175
 176         assertNotNull(copy);
 177
 178         assertFalse(copy.getGroupingBuilders().isEmpty());
 179         assertFalse(copy.getTypeDefinitionBuilders().isEmpty());
 180         assertFalse(copy.getUnknownNodes().isEmpty());
 181     }
 182
 183     private GroupingBuilder provideNestedGroupingDefinition(final QName parentName, final String groupLocalName) {
 184         final QName testGroup = QName.create(module.getNamespace(), module.getRevision(), groupLocalName);
 185         final SchemaPath groupPath = SchemaPath.create(true, parentName, testGroup);
 186         final GroupingBuilder grouping = module.addGrouping(12, testGroup, groupPath);
 187
 188         return grouping;
 189     }
 190
 191     private TypeDefinitionBuilder provideNestedTypedef(final QName parentName, final String typedefLocalName) {
 192         final QName typedefQname = QName.create(module.getNamespace(), module.getRevision(), typedefLocalName);
 193         final SchemaPath typedefPath = SchemaPath.create(true, parentName, typedefQname);
 194         final TypeDefinitionBuilder typedefBuilder = new TypeDefinitionBuilderImpl(module.getModuleName(), 12,
 195             typedefQname, typedefPath);
 196         typedefBuilder.setType(Uint16.getInstance());
 197
 198         return typedefBuilder;
 199     }
 200
 201     @Test
 202     public void testCopyLeafSchemaNodeBuilder() {
 203         final String leafLocalName = "original-leaf";
 204         final QName leafName = QName.create(module.getNamespace(), module.getRevision(), leafLocalName);
 205         final SchemaPath leafPath = SchemaPath.create(true, leafName);
 206         final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(module.getModuleName(), 22, leafName, leafPath);
 207         leafBuilder.setType(Uint16.getInstance());
 208
 209         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder(leafName);
 210         leafBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 211
 212         final LeafSchemaNodeBuilder copy = (LeafSchemaNodeBuilder)CopyUtils.copy(leafBuilder, module, true);
 213
 214         assertNotNull(copy);
 215         assertFalse(leafBuilder.getUnknownNodes().isEmpty());
 216     }
 217
 218     @Test
 219     public void testCopyLeafListSchemaNodeBuilder() {
 220         final String origLeafListLocalName = "original-list-to";
 221         final QName origLeafListQName = QName.create(module.getNamespace(), module.getRevision(), origLeafListLocalName );
 222         final SchemaPath origLeafListPath = SchemaPath.create(true, origLeafListQName);
 223         final LeafListSchemaNodeBuilder origLeafListBuilder = new LeafListSchemaNodeBuilder(module.getModuleName(),
 224             10, origLeafListQName, origLeafListPath);
 225         origLeafListBuilder.setType(Uint16.getInstance());
 226
 227         final String leafListLocalName = "leaflist-copy";
 228         final QName leafListQName = QName.create(module.getNamespace(), module.getRevision(), leafListLocalName);
 229         final SchemaPath leafListPath = SchemaPath.create(true, leafListQName);
 230         final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(module.getModuleName(),
 231             20, leafListQName, leafListPath);
 232         leafListBuilder.setType(Uint16.getInstance());
 233
 234         leafListBuilder.setOriginal(origLeafListBuilder);
 235         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder(leafListQName);
 236         leafListBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 237
 238         final LeafListSchemaNodeBuilder copy = (LeafListSchemaNodeBuilder)CopyUtils.copy(leafListBuilder, module, true);
 239
 240         assertNotNull(copy);
 241         assertFalse(copy.getUnknownNodes().isEmpty());
 242         assertNotNull(copy.getUnknownNodes().get(0));
 243     }
 244
 245     @Test
 246     public void testCopyListSchemaNodeBuilder() {
 247         final String origListLocalName = "original-list";
 248         final QName origListQName = QName.create(module.getNamespace(), module.getRevision(), origListLocalName);
 249         final SchemaPath origListPath = SchemaPath.create(true, origListQName);
 250         final ListSchemaNodeBuilder origListBuilder = new ListSchemaNodeBuilder(module.getModuleName(),
 251             10, origListQName, origListPath);
 252
 253         final String listLocalName = "copy-of-list";
 254         final QName listQName = QName.create(module.getNamespace(), module.getRevision(), listLocalName);
 255         final SchemaPath listPath = SchemaPath.create(true, listQName);
 256         final ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(module.getModuleName(),
 257             20, listQName, listPath);
 258
 259         listBuilder.setOriginal(origListBuilder);
 260
 261         final String groupLocalName = "test-group";
 262         final GroupingBuilder grouping = provideNestedGroupingDefinition(listBuilder.getQName(), groupLocalName);
 263         listBuilder.addGrouping(grouping);
 264
 265         final String typedefLocalName = "test-type-definition";
 266         final TypeDefinitionBuilder typedefBuilder = provideNestedTypedef(listBuilder.getQName(), typedefLocalName);
 267         listBuilder.addTypedef(typedefBuilder);
 268
 269         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder(listBuilder.getQName());
 270         listBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 271
 272         final UsesNodeBuilder usesNodeBuilder = provideUsesNodeBuilder("test-grouping-use");
 273         listBuilder.addUsesNode(usesNodeBuilder);
 274
 275         final SchemaPath augPath = SchemaPath.create(true, listBuilder.getQName());
 276         final AugmentationSchemaBuilder augBuilder = new AugmentationSchemaBuilderImpl(module.getModuleName(), 22,
 277             "/imaginary/path", augPath, 0);
 278         listBuilder.addAugmentation(augBuilder);
 279
 280         ListSchemaNodeBuilder copy = (ListSchemaNodeBuilder) CopyUtils.copy(listBuilder, module, true);
 281         assertNotNull(copy);
 282         assertFalse(copy.getGroupingBuilders().isEmpty());
 283         assertFalse(copy.getTypeDefinitionBuilders().isEmpty());
 284         assertFalse(copy.getUnknownNodes().isEmpty());
 285         assertFalse(copy.getUsesNodeBuilders().isEmpty());
 286         assertFalse(copy.getAugmentationBuilders().isEmpty());
 287     }
 288
 289     @Test
 290     public void testCopyGroupingBuilder() {
 291         final String groupLocalName = "test-group";
 292         final QName testGroup = QName.create(module.getNamespace(), module.getRevision(), groupLocalName);
 293         final SchemaPath groupPath = SchemaPath.create(true, testGroup);
 294         final GroupingBuilder grouping = module.addGrouping(12, testGroup, groupPath);
 295
 296         final String innerGroupLocalName = "inner-group";
 297         final QName innerGroup = QName.create(module.getNamespace(), module.getRevision(), innerGroupLocalName);
 298         final SchemaPath innerGroupPath = SchemaPath.create(true, testGroup, innerGroup);
 299         final GroupingBuilder innerGrouping = module.addGrouping(12, innerGroup, innerGroupPath);
 300
 301         grouping.addGrouping(innerGrouping);
 302
 303         final String typedefLocalName = "test-type-definition";
 304         final TypeDefinitionBuilder typedefBuilder = provideNestedTypedef(grouping.getQName(), typedefLocalName);
 305         grouping.addTypedef(typedefBuilder);
 306
 307         final UsesNodeBuilder usesNodeBuilder = provideUsesNodeBuilder(innerGroupLocalName);
 308         grouping.addUsesNode(usesNodeBuilder);
 309
 310         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder(grouping.getQName());
 311         grouping.addUnknownNodeBuilder(unknownNodeBuilder);
 312
 313         final GroupingBuilder copy = CopyUtils.copy(grouping, module, true);
 314         assertNotNull(copy);
 315         assertFalse(copy.getGroupingBuilders().isEmpty());
 316         assertFalse(copy.getTypeDefinitionBuilders().isEmpty());
 317         assertFalse(copy.getUsesNodeBuilders().isEmpty());
 318         assertFalse(copy.getUnknownNodes().isEmpty());
 319     }
 320
 321     @Test
 322     public void testCopyIdentityrefTypeBuilder() {
 323         final String typedefLocalName = "identity-ref-test-type";
 324         final QName typedefQname = QName.create(module.getNamespace(), module.getRevision(), typedefLocalName);
 325         final SchemaPath typedefPath = SchemaPath.create(true, typedefQname);
 326         final IdentityrefTypeBuilder typeBuilder = new IdentityrefTypeBuilder(module.getModuleName(), 12,
 327             "base:parent-identity", typedefPath);
 328
 329         final TypeDefinitionBuilder copy = CopyUtils.copy(typeBuilder, module, true);
 330         assertNotNull(copy);
 331
 332         //TODO: add additional asserts
 333     }
 334
 335     @Test
 336     public void testCopyTypeDefinitionBuilderWithUnknownNodes() {
 337         final String typedefLocalName = "test-typedef-with-ext";
 338         final QName typedefQname = QName.create(module.getNamespace(), module.getRevision(), typedefLocalName);
 339         final SchemaPath typedefPath = SchemaPath.create(true, typedefQname);
 340         final TypeDefinitionBuilder typedefBuilder = new TypeDefinitionBuilderImpl(module.getModuleName(), 12,
 341             typedefQname, typedefPath);
 342         typedefBuilder.setType(Uint16.getInstance());
 343
 344         typedefBuilder.addUnknownNodeBuilder(provideUnknownNodeBuilder());
 345
 346         TypeDefinitionBuilder copy = CopyUtils.copy(typedefBuilder, module, true);
 347         assertNotNull(copy);
 348         assertFalse(copy.getUnknownNodes().isEmpty());
 349     }
 350
 351     // FIXME: Use Mockito instead of this monstrosity
 352     private static final class InvalidDataSchemaNodeBuilder implements DataSchemaNodeBuilder {
 353
 354         @Override
 355         public SchemaNodeBuilder getOriginal() {
 356             return null;
 357         }
 358
 359         @Override
 360         public void setOriginal(final SchemaNodeBuilder original) {
 361
 362         }
 363
 364         @Override
 365         public boolean isAugmenting() {
 366             return false;
 367         }
 368
 369         @Override
 370         public void setAugmenting(final boolean augmenting) {
 371
 372         }
 373
 374         @Override
 375         public boolean isConfiguration() {
 376             return false;
 377         }
 378
 379         @Override
 380         public void setConfiguration(final boolean config) {
 381
 382         }
 383
 384         @Override
 385         public ConstraintsBuilder getConstraints() {
 386             return null;
 387         }
 388
 389         @Override
 390         public QName getQName() {
 391             return null;
 392         }
 393
 394         @Override
 395         public SchemaPath getPath() {
 396             return null;
 397         }
 398
 399         @Override
 400         public void setPath(final SchemaPath path) {
 401
 402         }
 403
 404         @Override
 405         public String getModuleName() {
 406             return null;
 407         }
 408
 409         @Override
 410         public int getLine() {
 411             return 0;
 412         }
 413
 414         @Override
 415         public Builder getParent() {
 416             return null;
 417         }
 418
 419         @Override
 420         public void setParent(final Builder parent) {
 421
 422         }
 423
 424         @Override
 425         public void addUnknownNodeBuilder(final UnknownSchemaNodeBuilder unknownNode) {
 426
 427         }
 428
 429         @Override
 430         public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
 431             return null;
 432         }
 433
 434         @Override
 435         public DataSchemaNode build() {
 436             return null;
 437         }
 438
 439         @Override
 440         public String getDescription() {
 441             return null;
 442         }
 443
 444         @Override
 445         public void setDescription(final String description) {
 446
 447         }
 448
 449         @Override
 450         public String getReference() {
 451             return null;
 452         }
 453
 454         @Override
 455         public void setReference(final String reference) {
 456
 457         }
 458
 459         @Override
 460         public Status getStatus() {
 461             return null;
 462         }
 463
 464         @Override
 465         public void setStatus(final Status status) {
 466
 467         }
 468
 469         @Override
 470         public boolean isAddedByUses() {
 471             return false;
 472         }
 473
 474         @Override
 475         public void setAddedByUses(final boolean addedByUses) {
 476
 477         }
 478     }
 479 }