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