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