binding/mdsal-binding-generator-impl/src/test/java/org/opendaylight/mdsal/binding/yang/types/TypeProviderTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.mdsal.binding.yang.types;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.Mockito.doReturn;
  15
  16 import com.google.common.collect.Range;
  17 import java.util.List;
  18 import java.util.Optional;
  19 import java.util.Set;
  20 import org.junit.Before;
  21 import org.junit.Ignore;
  22 import org.junit.Test;
  23 import org.junit.runner.RunWith;
  24 import org.junit.runners.JUnit4;
  25 import org.mockito.Mock;
  26 import org.mockito.MockitoAnnotations;
  27 import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
  28 import org.opendaylight.mdsal.binding.model.api.ConcreteType;
  29 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  30 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  31 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
  32 import org.opendaylight.mdsal.binding.model.api.Restrictions;
  33 import org.opendaylight.mdsal.binding.model.api.Type;
  34 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
  35 import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
  36 import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl;
  37 import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
  38 import org.opendaylight.yangtools.yang.common.QName;
  39 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  40 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  41 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  42 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  43 import org.opendaylight.yangtools.yang.model.api.Module;
  44 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  45 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  46 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  47 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  48 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
  49 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  50 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  51 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  52 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  53
  54 /**
  55  * Test suite for testing public methods in TypeProviderImpl class
  56  *
  57  * @see org.opendaylight.mdsal.binding.yang.types.TypeProviderImpl
  58  *
  59  * @author Lukas Sedlak &lt;lsedlak@cisco.com&gt;
  60  */
  61 @RunWith(JUnit4.class)
  62 public class TypeProviderTest {
  63
  64     private SchemaContext schemaContext;
  65     private Set<Module> schemaModules;
  66     private Module testTypeProviderModule;
  67
  68     @Mock
  69     private SchemaPath schemaPath;
  70
  71     @Mock
  72     private SchemaNode schemaNode;
  73
  74     @Before
  75     public void setUp() throws SourceException, ReactorException {
  76         MockitoAnnotations.initMocks(this);
  77         this.schemaContext = TypeProviderModel.createTestContext();
  78         assertNotNull(this.schemaContext);
  79         this.schemaModules = this.schemaContext.getModules();
  80         assertNotNull(this.schemaModules);
  81         this.testTypeProviderModule = resolveModule(TypeProviderModel.TEST_TYPE_PROVIDER_MODULE_NAME);
  82         assertNotNull(this.testTypeProviderModule);
  83     }
  84
  85     private Module resolveModule(final String moduleName) {
  86         assertNotNull(moduleName);
  87         for (final Module m : this.schemaModules) {
  88             if (moduleName.equals(m.getName())) {
  89                 return m;
  90             }
  91         }
  92         assertTrue("Unable to resolve module " + moduleName + ". No module present within Schema Context!" , false);
  93         return null;
  94     }
  95
  96     @Test(expected = IllegalArgumentException.class)
  97     public void typeProviderInstanceWithNullSchemaContextTest() {
  98         new RuntimeTypeProvider(null);
  99     }
 100
 101     @Test(expected = IllegalArgumentException.class)
 102     public void putReferencedTypeWithNullSchemaPathParamTest() {
 103         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 104
 105         provider.putReferencedType(null, null);
 106         provider.putReferencedType(this.schemaPath, null);
 107     }
 108
 109     @Test(expected = IllegalArgumentException.class)
 110     public void putReferencedTypeWithNullRefTypeParamTest() {
 111         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 112
 113         provider.putReferencedType(this.schemaPath, null);
 114     }
 115
 116     @Test
 117     public void getAdditionalTypesTest() {
 118         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 119
 120         assertNotNull(provider.getAdditionalTypes());
 121     }
 122
 123     @Test(expected = IllegalArgumentException.class)
 124     public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
 125         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 126
 127         provider.javaTypeForSchemaDefinitionType(null, null, null);
 128     }
 129
 130     @Test(expected = IllegalArgumentException.class)
 131     public void javaTypeForSchemaDefinitionTypeTypedefNullQNameTest() {
 132         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 133
 134         final TestIntegerTypeDefinition testTypedef = new TestIntegerTypeDefinition();
 135         provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
 136     }
 137
 138     private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName, final String leafNodeName) {
 139         final QName containerNode = QName.create(module.getQNameModule(), containerName);
 140         final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
 141         assertNotNull("Container foo is not present in root of module "+ module.getName(), rootNode);
 142         assertTrue(rootNode instanceof DataNodeContainer);
 143
 144         final QName leafNode = QName.create(module.getQNameModule(), leafNodeName);
 145         final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
 146         final DataSchemaNode node = rootContainer.getDataChildByName(leafNode);
 147         assertNotNull(node);
 148         assertTrue(node instanceof LeafSchemaNode);
 149         return (LeafSchemaNode) node;
 150     }
 151
 152     private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module, final String containerName, final String leafListNodeName) {
 153         final QName containerNode = QName.create(module.getQNameModule(), containerName);
 154         final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
 155         assertNotNull("Container foo is not present in root of module " + module.getName(), rootNode);
 156         assertTrue(rootNode instanceof DataNodeContainer);
 157
 158         final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
 159         final QName leafListNode = QName.create(module.getQNameModule(), leafListNodeName);
 160         final DataSchemaNode node = rootContainer.getDataChildByName(leafListNode);
 161         assertNotNull(node);
 162         assertTrue(node instanceof LeafListSchemaNode);
 163         return (LeafListSchemaNode) node;
 164     }
 165
 166     @Test
 167     public void javaTypeForSchemaDefinitionExtTypeTest() {
 168         final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 169         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 170
 171         final TypeDefinition<?> leafType = leaf.getType();
 172         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 173         assertNotNull(result);
 174         assertTrue(result instanceof GeneratedTransferObject);
 175
 176         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 177         assertEquals("base-yang-types", genTO.getModuleName());
 178         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
 179         assertEquals("YangInt8", genTO.getName());
 180         assertEquals(1, genTO.getProperties().size());
 181     }
 182
 183     @Test
 184     public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
 185         final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 186         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "restricted-int8-type");
 187
 188         final TypeDefinition<?> leafType = leaf.getType();
 189         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 190
 191         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 192         assertNotNull(result);
 193         assertTrue(result instanceof GeneratedTransferObject);
 194
 195         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 196         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
 197         assertEquals("YangInt8Restricted", genTO.getName());
 198         assertEquals(1, genTO.getProperties().size());
 199         final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
 200
 201         assertTrue(rangeConstraints.isPresent());
 202         final Range<?> constraint = rangeConstraints.get().getAllowedRanges().asRanges().iterator().next();
 203         assertEquals((byte) 1, constraint.lowerEndpoint());
 204         assertEquals((byte) 100, constraint.upperEndpoint());
 205     }
 206
 207     @Test
 208     public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
 209         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 210
 211         final Module testTypeProvider = resolveModule("test-type-provider");
 212         final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider, "empty-pattern-string");
 213
 214         assertNotNull(emptyPatternString);
 215         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
 216
 217         Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
 218         assertNotNull(result);
 219         assertTrue(result instanceof GeneratedTransferObject);
 220
 221         result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
 222         assertNotNull(result);
 223         assertTrue(result instanceof GeneratedTransferObject);
 224     }
 225
 226     private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
 227         TypeDefinition<?> result = null;
 228         final Set<TypeDefinition<?>> typeDefs = module.getTypeDefinitions();
 229         for (final TypeDefinition<?> typedef : typeDefs) {
 230             if (typedef.getQName().getLocalName().equals(typedefName)) {
 231                 result = typedef;
 232             }
 233         }
 234         return result;
 235     }
 236
 237     /**
 238      * FIXME: Remove @Ignore annotation once the bug https://bugs.opendaylight.org/show_bug.cgi?id=1862 is fixed
 239      */
 240     @Ignore
 241     @Test
 242     public void bug1862RestrictedTypedefTransformationTest() {
 243         final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 244         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
 245             "bug-1862-restricted-typedef");
 246
 247         final TypeDefinition<?> leafType = leaf.getType();
 248         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 249         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 250         assertNotNull(result);
 251         assertTrue(result instanceof GeneratedTransferObject);
 252         //TODO: complete test after bug 1862 is fixed
 253     }
 254
 255     @Test
 256     public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
 257         final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 258         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
 259             "resolve-enum-leaf");
 260         TypeDefinition<?> leafType = leaf.getType();
 261         Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 262         assertNotNull(result);
 263         assertTrue(result instanceof Enumeration);
 264
 265         final Enumeration enumType = (Enumeration) result;
 266         final List<Enumeration.Pair> enumValues = enumType.getValues();
 267         assertTrue(!enumValues.isEmpty());
 268         assertEquals("a", enumValues.get(0).getName());
 269         assertEquals("b", enumValues.get(1).getName());
 270         assertEquals("A", enumValues.get(0).getMappedName());
 271         assertEquals("B", enumValues.get(1).getMappedName());
 272
 273         leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "resolve-direct-use-of-enum");
 274         leafType = leaf.getType();
 275         result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 276         assertNotNull(result);
 277         assertTrue(result instanceof ConcreteType);
 278
 279         assertEquals("java.lang", result.getPackageName());
 280         assertEquals("Enum", result.getName());
 281     }
 282
 283     @Test
 284     public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
 285         final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 286         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "bar", "leafref-value");
 287         TypeDefinition<?> leafType = leaf.getType();
 288         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 289         assertNotNull(leafrefResolvedType1);
 290         assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
 291
 292         final Module module = resolveModule("test-type-provider-b");
 293         final QName leafNode = QName.create(module.getQNameModule(), "id");
 294         final DataSchemaNode rootNode = module.getDataChildByName(leafNode);
 295         assertNotNull("leaf id is not present in root of module "+ module.getName(), rootNode);
 296         assertTrue(rootNode instanceof LeafSchemaNode);
 297         leaf = (LeafSchemaNode) rootNode;
 298         leafType = leaf.getType();
 299
 300         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 301         assertNotNull(leafrefResolvedType2);
 302         assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
 303     }
 304
 305     @Test
 306     public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
 307         final AbstractTypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 308
 309         setReferencedTypeForTypeProvider(provider);
 310
 311         final Module module = resolveModule("test-type-provider-b");
 312
 313         final QName leafNode = QName.create(module.getQNameModule(), "enum");
 314         final DataSchemaNode enumNode = module.getDataChildByName(leafNode);
 315         assertNotNull("leaf enum is not present in root of module " + module.getName(), enumNode);
 316         assertTrue(enumNode instanceof LeafSchemaNode);
 317         final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
 318         final TypeDefinition<?> leafType = leaf.getType();
 319
 320         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 321         assertNotNull(leafrefResolvedType1);
 322         assertTrue(leafrefResolvedType1 instanceof ReferencedTypeImpl);
 323
 324         final QName leafListNode = QName.create(module.getQNameModule(), "enums");
 325         final DataSchemaNode enumListNode = module.getDataChildByName(leafListNode);
 326         assertNotNull("leaf-list enums is not present in root of module " + module.getName(), enumNode);
 327         assertTrue(enumListNode instanceof LeafListSchemaNode);
 328         final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
 329         final TypeDefinition<?> leafListType = leafList.getType();
 330
 331         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
 332         assertNotNull(leafrefResolvedType2);
 333         assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
 334     }
 335
 336     private void setReferencedTypeForTypeProvider(final AbstractTypeProvider provider) {
 337         final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
 338             "resolve-direct-use-of-enum");
 339         final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
 340         Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
 341
 342         Type refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getName());
 343         provider.putReferencedType(enumLeafNode.getPath(), refType);
 344
 345         final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(this.testTypeProviderModule,
 346             "foo", "list-of-enums");
 347         final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
 348         enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
 349
 350         refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getPackageName());
 351         provider.putReferencedType(enumListNode.getPath(), refType);
 352     }
 353
 354     @Test
 355     public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
 356         final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 357         final Module module = resolveModule("test-type-provider-b");
 358
 359         final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
 360         final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
 361         assertNotNull("leaf conditional-leafref is not present in root of module "+ module.getName(), condLeaf);
 362         assertTrue(condLeaf instanceof LeafSchemaNode);
 363         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 364         final TypeDefinition<?> leafType = leaf.getType();
 365
 366         final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 367         assertNotNull(resultType);
 368         assertTrue(resultType instanceof ConcreteType);
 369         assertEquals("java.lang", resultType.getPackageName());
 370         assertEquals("Object", resultType.getName());
 371     }
 372
 373     @Test(expected = IllegalArgumentException.class)
 374     public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
 375         final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 376         final Module module = resolveModule("test-type-provider-b");
 377
 378         final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
 379         final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
 380         assertNotNull("leaf unreslovable-leafref is not present in root of module "+ module.getName(), condLeaf);
 381         assertTrue(condLeaf instanceof LeafSchemaNode);
 382         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 383         final TypeDefinition<?> leafType = leaf.getType();
 384
 385         provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 386     }
 387
 388     @Test(expected = IllegalArgumentException.class)
 389     public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
 390         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 391
 392         provider.provideTypeForLeafref(null, null);
 393     }
 394
 395     @Test(expected = IllegalArgumentException.class)
 396     public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
 397         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 398
 399         final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
 400         provider.provideTypeForLeafref(leafrePath, this.schemaNode);
 401     }
 402
 403     @Test(expected = IllegalStateException.class)
 404     public void provideTypeForLeafrefWithNullParentModuleTest() {
 405         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 406         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "bar",
 407             "leafref-value");
 408         final TypeDefinition<?> leafType = leaf.getType();
 409         assertTrue(leafType instanceof LeafrefTypeDefinition);
 410         doReturn(null).when(this.schemaNode).getPath();
 411         provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, this.schemaNode);
 412     }
 413
 414     @Test
 415     public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
 416         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 417         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "crypto");
 418         final TypeDefinition<?> leafType = leaf.getType();
 419
 420         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 421         assertNotNull(result);
 422         assertTrue(result instanceof ParameterizedType);
 423     }
 424
 425     @Test
 426     public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
 427         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 428         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "simple-int-types-union");
 429         final TypeDefinition<?> leafType = leaf.getType();
 430
 431         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 432         assertNotNull(result);
 433         assertTrue(result instanceof GeneratedTransferObject);
 434         assertEquals("YangUnion", result.getName());
 435         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 436     }
 437
 438     @Test
 439     public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
 440         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 441         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-union");
 442         final TypeDefinition<?> leafType = leaf.getType();
 443
 444         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 445         assertNotNull(result);
 446         assertTrue(result instanceof GeneratedTransferObject);
 447         assertEquals("ComplexUnion", result.getName());
 448         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 449     }
 450
 451     @Test
 452     public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
 453         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 454         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-string-int-union");
 455         final TypeDefinition<?> leafType = leaf.getType();
 456
 457         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 458         assertNotNull(result);
 459         assertTrue(result instanceof GeneratedTransferObject);
 460         assertEquals("ComplexStringIntUnion", result.getName());
 461         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 462     }
 463
 464     @Test
 465     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
 466         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 467
 468         final Module testTypeProvider = resolveModule("test-type-provider");
 469         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-union");
 470
 471         assertNotNull(unionTypeDef);
 472         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 473         GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
 474             (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexUnionType", unionTypeDef);
 475
 476         assertNotNull(unionTypeBuilder);
 477
 478         GeneratedTransferObject unionType = unionTypeBuilder.build();
 479         assertEquals("ComplexUnionType", unionType.getName());
 480
 481         unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
 482             (UnionTypeDefinition)unionTypeDef.getBaseType(), "", unionTypeDef);
 483
 484         assertNotNull(unionTypeBuilder);
 485
 486         unionType = unionTypeBuilder.build();
 487         assertEquals("Union", unionType.getName());
 488
 489         unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
 490             (UnionTypeDefinition)unionTypeDef.getBaseType(), null, unionTypeDef);
 491
 492         assertNotNull(unionTypeBuilder);
 493
 494         unionType = unionTypeBuilder.build();
 495         assertEquals("Union", unionType.getName());
 496     }
 497
 498     @Test
 499     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
 500         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 501
 502         final Module testTypeProvider = resolveModule("test-type-provider");
 503         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider,
 504             "complex-string-int-union");
 505
 506         assertNotNull(unionTypeDef);
 507         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 508         final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
 509             "test.package.name",(UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexStringIntUnionType",
 510             unionTypeDef);
 511
 512         assertNotNull(unionTypeBuilder);
 513
 514         final GeneratedTransferObject unionType = unionTypeBuilder.build();
 515         assertEquals("ComplexStringIntUnionType", unionType.getName());
 516     }
 517
 518     @Test
 519     public void generatedTypeForExtendedDefinitionTypeTest() {
 520         final AbstractTypeProvider provider = new CodegenTypeProvider(this.schemaContext);
 521
 522         final Module baseYangTypes = resolveModule("base-yang-types");
 523         final Set<TypeDefinition<?>> typeDefs = baseYangTypes.getTypeDefinitions();
 524
 525         Type yangBoolean = null;
 526         Type yangEmpty = null;
 527         Type yangEnumeration = null;
 528         Type yangInt8 = null;
 529         Type yangInt8Restricted = null;
 530         Type yangInt16 = null;
 531         Type yangInt32 = null;
 532         Type yangInt64 = null;
 533         Type yangString = null;
 534         Type yangDecimal = null;
 535         Type yangUint8 = null;
 536         Type yangUint16 = null;
 537         Type yangUint32 = null;
 538         Type yangUint64 = null;
 539         Type yangUnion = null;
 540         Type yangBinary = null;
 541         Type yangBits = null;
 542         Type yangInstanceIdentifier = null;
 543
 544         for (final TypeDefinition<?> typedef : typeDefs) {
 545             final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
 546             if (type instanceof GeneratedTransferObject) {
 547                 if (type.getName().equals("YangBoolean")) {
 548                     yangBoolean = type;
 549                 } else if (type.getName().equals("YangEmpty")) {
 550                     yangEmpty = type;
 551                 } else if (type.getName().equals("YangInt8")) {
 552                     yangInt8 = type;
 553                 } else if (type.getName().equals("YangInt8Restricted")) {
 554                     yangInt8Restricted = type;
 555                 } else if (type.getName().equals("YangInt16")) {
 556                     yangInt16 = type;
 557                 } else if (type.getName().equals("YangInt32")) {
 558                     yangInt32 = type;
 559                 } else if (type.getName().equals("YangInt64")) {
 560                     yangInt64 = type;
 561                 } else if (type.getName().equals("YangString")) {
 562                     yangString = type;
 563                 } else if (type.getName().equals("YangDecimal64")) {
 564                     yangDecimal = type;
 565                 } else if (type.getName().equals("YangUint8")) {
 566                     yangUint8 = type;
 567                 } else if (type.getName().equals("YangUint16")) {
 568                     yangUint16 = type;
 569                 } else if (type.getName().equals("YangUint32")) {
 570                     yangUint32 = type;
 571                 } else if (type.getName().equals("YangUint64")) {
 572                     yangUint64 = type;
 573                 } else if (type.getName().equals("YangUnion")) {
 574                     yangUnion = type;
 575                 } else if (type.getName().equals("YangBinary")) {
 576                     yangBinary = type;
 577                 } else if (type.getName().equals("YangInstanceIdentifier")) {
 578                     yangInstanceIdentifier = type;
 579                 } else if (type.getName().equals("YangBits")) {
 580                     yangBits = type;
 581                 }
 582             } else if (type instanceof Enumeration) {
 583                 if (type.getName().equals("YangEnumeration")) {
 584                     yangEnumeration = type;
 585                 }
 586             }
 587         }
 588
 589         assertNotNull(yangBoolean);
 590         assertNotNull(yangEmpty);
 591         assertNotNull(yangEnumeration);
 592         assertNotNull(yangInt8);
 593         assertNotNull(yangInt8Restricted);
 594         assertNotNull(yangInt16);
 595         assertNotNull(yangInt32);
 596         assertNotNull(yangInt64);
 597         assertNotNull(yangString);
 598         assertNotNull(yangDecimal);
 599         assertNotNull(yangUint8);
 600         assertNotNull(yangUint16);
 601         assertNotNull(yangUint32);
 602         assertNotNull(yangUint64);
 603         assertNotNull(yangUnion);
 604         assertNotNull(yangBinary);
 605         assertNotNull(yangBits);
 606         assertNotNull(yangInstanceIdentifier);
 607     }
 608
 609     @Test(expected = IllegalArgumentException.class)
 610     public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
 611         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 612         provider.generatedTypeForExtendedDefinitionType(null, null);
 613     }
 614
 615     @Test(expected = IllegalArgumentException.class)
 616     public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
 617         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 618         final TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
 619         provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
 620     }
 621
 622     @Test
 623     public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
 624         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 625
 626         final Module baseYangTypes = resolveModule("test-type-provider");
 627         final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes,
 628             "extended-yang-int8");
 629         assertNotNull(extYangInt8Typedef);
 630         final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
 631         assertNotNull(extType);
 632         assertTrue(extType instanceof GeneratedTransferObject);
 633     }
 634
 635     @Test
 636     public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
 637         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 638
 639         final Module baseYangTypes = resolveModule("test-type-provider");
 640         final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes, "bar-item-leafref-id");
 641         assertNotNull(barItemLeafrefId);
 642         final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
 643         assertEquals(null, extType);
 644     }
 645
 646     @Test
 647     public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
 648         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 649
 650         final Module baseYangTypes = resolveModule("test-type-provider");
 651
 652         final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes, "aes-identityref-type");
 653
 654         assertNotNull(aesIdentityrefType);
 655         final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
 656         assertEquals(null, extType);
 657     }
 658
 659     @Test(expected = IllegalArgumentException.class)
 660     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
 661         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 662         provider.provideGeneratedTOBuilderForBitsTypeDefinition("", null, "", "");
 663     }
 664
 665     @Test(expected = IllegalArgumentException.class)
 666     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithBasePackageNullTest() {
 667         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 668         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 669         final TypeDefinition<?> leafType = leaf.getType();
 670         provider.provideGeneratedTOBuilderForBitsTypeDefinition(null, leafType, "", "");
 671     }
 672
 673     @Test
 674     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNonBitsTypedefTest() {
 675         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 676
 677         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 678         final TypeDefinition<?> leafType = leaf.getType();
 679         final Type type = provider.provideGeneratedTOBuilderForBitsTypeDefinition("", leafType, "", "");
 680
 681         assertEquals(null, type);
 682     }
 683
 684     @Test
 685     public void getConstructorPropertyNameTest() {
 686         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 687
 688         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 689         final TypeDefinition<?> leafType = leaf.getType();
 690
 691         final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
 692         assertEquals("value", ctorPropertyName);
 693
 694         final String emptyStringName = provider.getConstructorPropertyName(leaf);
 695         assertTrue(emptyStringName.isEmpty());
 696     }
 697
 698     @Test
 699     public void getParamNameFromTypeTest() {
 700         final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 701
 702         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 703         final TypeDefinition<?> leafType = leaf.getType();
 704
 705         final String paramName = provider.getParamNameFromType(leafType);
 706         assertEquals("yangInt8", paramName);
 707     }
 708
 709     @Test
 710     public void addUnitsToGenTOTest() {
 711         final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder("test.package", "TestBuilder");
 712
 713         CodegenTypeProvider.addUnitsToGenTO(builder, null);
 714         GeneratedTransferObject genTO = builder.build();
 715         assertTrue(genTO.getConstantDefinitions().isEmpty());
 716
 717         CodegenTypeProvider.addUnitsToGenTO(builder, "");
 718         genTO = builder.build();
 719         assertTrue(genTO.getConstantDefinitions().isEmpty());
 720
 721         CodegenTypeProvider.addUnitsToGenTO(builder, "125");
 722         genTO = builder.build();
 723         assertTrue(!genTO.getConstantDefinitions().isEmpty());
 724         assertEquals(1, genTO.getConstantDefinitions().size());
 725         assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
 726         assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
 727     }
 728
 729     @Test(expected = NullPointerException.class)
 730     public void getTypeDefaultConstructionLeafTypeNullTest() {
 731         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 732         final TestLeafSchemaNode leafSchemaNode = new TestLeafSchemaNode();
 733         provider.getTypeDefaultConstruction(leafSchemaNode, null);
 734     }
 735
 736     @Test(expected = NullPointerException.class)
 737     public void getTypeDefaultConstructionDefaultValueNullTest() {
 738         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 739         final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
 740         provider.getTypeDefaultConstruction(leaf, null);
 741     }
 742
 743     private LeafSchemaNode provideLeafForGetDefaultConstructionTestCase(final String leafName) {
 744         return provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "construction-type-test",
 745             leafName);
 746     }
 747
 748     @Test(expected = UnsupportedOperationException.class)
 749     public void getTypeDefaultConstructionDefaultValueForInstanceIdentifierTest() {
 750         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 751         final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("foo-container-id");
 752         provider.getTypeDefaultConstruction(leaf, "NAN");
 753     }
 754
 755     @Test(expected = UnsupportedOperationException.class)
 756     public void getTypeDefaultConstructionDefaultValueForIdentityrefTest() {
 757         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 758         final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("aes-identityref-type");
 759         provider.getTypeDefaultConstruction(leaf, "NAN");
 760     }
 761
 762     @Test
 763     public void getTypeDefaultConstructionDefaultValueTest() {
 764         final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
 765
 766         LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
 767         String result = provider.getTypeDefaultConstruction(leaf, "true");
 768         assertNotNull(result);
 769         assertTrue(!result.isEmpty());
 770         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBoolean(java.lang.Boolean.TRUE)",
 771             result);
 772
 773         leaf = provideLeafForGetDefaultConstructionTestCase("yang-empty");
 774         result = provider.getTypeDefaultConstruction(leaf, "true");
 775         assertNotNull(result);
 776         assertTrue(!result.isEmpty());
 777         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEmpty(java.lang.Boolean.TRUE)",
 778             result);
 779
 780         leaf = provideLeafForGetDefaultConstructionTestCase("yang-enumeration");
 781         result = provider.getTypeDefaultConstruction(leaf, "a");
 782         assertNotNull(result);
 783         assertTrue(!result.isEmpty());
 784         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEnumeration.A",
 785             result);
 786
 787         leaf = provideLeafForGetDefaultConstructionTestCase("direct-use-of-enum");
 788         result = provider.getTypeDefaultConstruction(leaf, "y");
 789         assertNotNull(result);
 790         assertTrue(!result.isEmpty());
 791         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.construction.type.test.DirectUseOfEnum.Y",
 792             result);
 793
 794         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8");
 795         result = provider.getTypeDefaultConstruction(leaf, "17");
 796         assertNotNull(result);
 797         assertTrue(!result.isEmpty());
 798         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"17\"))",
 799             result);
 800
 801         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8-restricted");
 802         result = provider.getTypeDefaultConstruction(leaf, "99");
 803         assertNotNull(result);
 804         assertTrue(!result.isEmpty());
 805         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8Restricted(java.lang.Byte.valueOf(\"99\"))",
 806             result);
 807
 808         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int16");
 809         result = provider.getTypeDefaultConstruction(leaf, "1024");
 810         assertNotNull(result);
 811         assertTrue(!result.isEmpty());
 812         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"1024\"))",
 813             result);
 814
 815         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int32");
 816         result = provider.getTypeDefaultConstruction(leaf, "1048576");
 817         assertNotNull(result);
 818         assertTrue(!result.isEmpty());
 819         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt32(java.lang.Integer.valueOf(\"1048576\"))",
 820             result);
 821
 822         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int64");
 823         result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
 824         assertNotNull(result);
 825         assertTrue(!result.isEmpty());
 826         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt64(java.lang.Long.valueOf(\"1099511627776\"))",
 827             result);
 828
 829         leaf = provideLeafForGetDefaultConstructionTestCase("yang-string");
 830         result = provider.getTypeDefaultConstruction(leaf, "TEST");
 831         assertNotNull(result);
 832         assertTrue(!result.isEmpty());
 833         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangString(\"TEST\")",
 834             result);
 835
 836         leaf = provideLeafForGetDefaultConstructionTestCase("yang-decimal64");
 837         result = provider.getTypeDefaultConstruction(leaf, "1274.25");
 838         assertNotNull(result);
 839         assertTrue(!result.isEmpty());
 840         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangDecimal64(new java.math.BigDecimal(\"1274.25\"))",
 841             result);
 842
 843         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint8");
 844         result = provider.getTypeDefaultConstruction(leaf, "128");
 845         assertNotNull(result);
 846         assertTrue(!result.isEmpty());
 847         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint8(java.lang.Short.valueOf(\"128\"))",
 848             result);
 849
 850         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint16");
 851         result = provider.getTypeDefaultConstruction(leaf, "1048576");
 852         assertNotNull(result);
 853         assertTrue(!result.isEmpty());
 854         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint16(java.lang.Integer.valueOf(\"1048576\"))",
 855             result);
 856
 857         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint32");
 858         result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
 859         assertNotNull(result);
 860         assertTrue(!result.isEmpty());
 861         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint32(java.lang.Long.valueOf(\"1099511627776\"))",
 862             result);
 863
 864         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint64");
 865         result = provider.getTypeDefaultConstruction(leaf, "1208925819614629174706176");
 866         assertNotNull(result);
 867         assertTrue(!result.isEmpty());
 868         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint64(new java.math.BigInteger(\"1208925819614629174706176\"))",
 869             result);
 870
 871         //FIXME: Is this correct scenario and correct result?
 872         leaf = provideLeafForGetDefaultConstructionTestCase("complex-union");
 873         result = provider.getTypeDefaultConstruction(leaf, "75");
 874         assertNotNull(result);
 875         assertTrue(!result.isEmpty());
 876         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexUnion(\"null\".toCharArray())",
 877             result);
 878
 879         //FIXME: Is this correct scenario and correct result?
 880         leaf = provideLeafForGetDefaultConstructionTestCase("complex-string-int-union");
 881         result = provider.getTypeDefaultConstruction(leaf, "TEST_UNION_STRING_DEFAULT");
 882         assertNotNull(result);
 883         assertTrue(!result.isEmpty());
 884         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexStringIntUnion(\"null\".toCharArray())",
 885             result);
 886
 887         leaf = provideLeafForGetDefaultConstructionTestCase("simple-int-types-union");
 888         result = provider.getTypeDefaultConstruction(leaf, "2048");
 889         assertNotNull(result);
 890         assertTrue(!result.isEmpty());
 891         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUnion(\"null\".toCharArray())",
 892             result);
 893
 894
 895         leaf = provideLeafForGetDefaultConstructionTestCase("direct-union-leaf");
 896         result = provider.getTypeDefaultConstruction(leaf);
 897         assertNotNull(result);
 898         assertTrue(!result.isEmpty());
 899         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.DirectUnionLeaf(\"128\".toCharArray())",
 900             result);
 901
 902         final Module module = resolveModule("test-type-provider");
 903         final QName leafUnionNode = QName.create(module.getQNameModule(), "root-union-leaf");
 904         DataSchemaNode rootNode = module.getDataChildByName(leafUnionNode);
 905         assertNotNull("leaf root-union-leaf is not present in root of module "+ module.getName(), rootNode);
 906         assertTrue(rootNode instanceof LeafSchemaNode);
 907         leaf = (LeafSchemaNode) rootNode;
 908         result = provider.getTypeDefaultConstruction(leaf);
 909         assertNotNull(result);
 910         assertTrue(!result.isEmpty());
 911         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootUnionLeaf(\"256\".toCharArray())",
 912             result);
 913
 914         leaf = provideLeafForGetDefaultConstructionTestCase("yang-binary");
 915         result = provider.getTypeDefaultConstruction(leaf, "0xffffff");
 916         assertNotNull(result);
 917         assertTrue(!result.isEmpty());
 918         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBinary(new byte[] {-45, 23, -33, 125, -9, -33})",
 919             result);
 920
 921         final QName leafBitsNode = QName.create(module.getQNameModule(), "root-bits-leaf");
 922         rootNode = module.getDataChildByName(leafBitsNode);
 923         assertNotNull("leaf bits-leaf is not present in root of module "+ module.getName(), rootNode);
 924         assertTrue(rootNode instanceof LeafSchemaNode);
 925         leaf = (LeafSchemaNode) rootNode;
 926         result = provider.getTypeDefaultConstruction(leaf);
 927         assertNotNull(result);
 928         assertTrue(!result.isEmpty());
 929         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootBitsLeaf(true, false, false)",
 930             result);
 931
 932         leaf = provideLeafForGetDefaultConstructionTestCase("yang-bits");
 933         result = provider.getTypeDefaultConstruction(leaf, "only-10-Mb");
 934         assertNotNull(result);
 935         assertTrue(!result.isEmpty());
 936         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBits(false, false, true)",
 937             result);
 938
 939         leaf = provideLeafForGetDefaultConstructionTestCase("bar-id");
 940         result = provider.getTypeDefaultConstruction(leaf, "128");
 941         assertNotNull(result);
 942         assertTrue(!result.isEmpty());
 943         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"128\"))",
 944             result);
 945
 946         leaf = provideLeafForGetDefaultConstructionTestCase("foo-leafref-value");
 947         result = provider.getTypeDefaultConstruction(leaf, "32");
 948         assertNotNull(result);
 949         assertTrue(!result.isEmpty());
 950         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"32\"))",
 951             result);
 952
 953         leaf = provideLeafForGetDefaultConstructionTestCase("foo-cond-bar-item");
 954         result = provider.getTypeDefaultConstruction(leaf, "10");
 955         assertNotNull(result);
 956         assertTrue(!result.isEmpty());
 957         assertEquals("new java.lang.Object()",
 958             result);
 959     }
 960 }