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