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.GeneratedTOBuilderImpl;
  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         final TypeProvider provider = new TypeProviderImpl(null);
  99     }
 100
 101     @Test(expected = IllegalArgumentException.class)
 102     public void putReferencedTypeWithNullSchemaPathParamTest() {
 103         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 104
 105         ((TypeProviderImpl) provider).putReferencedType(null, null);
 106         ((TypeProviderImpl) provider).putReferencedType(this.schemaPath, null);
 107     }
 108
 109     @Test(expected = IllegalArgumentException.class)
 110     public void putReferencedTypeWithNullRefTypeParamTest() {
 111         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 112
 113         ((TypeProviderImpl) provider).putReferencedType(this.schemaPath, null);
 114     }
 115
 116     @Test
 117     public void getAdditionalTypesTest() {
 118         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 119
 120         assertNotNull(((TypeProviderImpl) provider).getAdditionalTypes());
 121     }
 122
 123     @Test(expected = IllegalArgumentException.class)
 124     public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
 125         final TypeProvider provider = new TypeProviderImpl(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 TypeProviderImpl(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 TypeProviderImpl(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 TypeProviderImpl(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 TypeProviderImpl provider = new TypeProviderImpl(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 TypeProviderImpl(this.schemaContext);
 244         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "bug-1862-restricted-typedef");
 245
 246         final TypeDefinition<?> leafType = leaf.getType();
 247         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 248         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 249         assertNotNull(result);
 250         assertTrue(result instanceof GeneratedTransferObject);
 251         //TODO: complete test after bug 1862 is fixed
 252     }
 253
 254     @Test
 255     public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
 256         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 257         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "resolve-enum-leaf");
 258         TypeDefinition<?> leafType = leaf.getType();
 259         Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 260         assertNotNull(result);
 261         assertTrue(result instanceof Enumeration);
 262
 263         final Enumeration enumType = (Enumeration) result;
 264         final List<Enumeration.Pair> enumValues = enumType.getValues();
 265         assertTrue(!enumValues.isEmpty());
 266         assertEquals("a", enumValues.get(0).getName());
 267         assertEquals("b", enumValues.get(1).getName());
 268         assertEquals("A", enumValues.get(0).getMappedName());
 269         assertEquals("B", enumValues.get(1).getMappedName());
 270
 271         leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "resolve-direct-use-of-enum");
 272         leafType = leaf.getType();
 273         result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 274         assertNotNull(result);
 275         assertTrue(result instanceof ConcreteType);
 276
 277         assertEquals("java.lang", result.getPackageName());
 278         assertEquals("Enum", result.getName());
 279     }
 280
 281     @Test
 282     public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
 283         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 284         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "bar", "leafref-value");
 285         TypeDefinition<?> leafType = leaf.getType();
 286         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 287         assertNotNull(leafrefResolvedType1);
 288         assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
 289
 290         final Module module = resolveModule("test-type-provider-b");
 291         final QName leafNode = QName.create(module.getQNameModule(), "id");
 292         final DataSchemaNode rootNode = module.getDataChildByName(leafNode);
 293         assertNotNull("leaf id is not present in root of module "+ module.getName(), rootNode);
 294         assertTrue(rootNode instanceof LeafSchemaNode);
 295         leaf = (LeafSchemaNode) rootNode;
 296         leafType = leaf.getType();
 297
 298         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 299         assertNotNull(leafrefResolvedType2);
 300         assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
 301     }
 302
 303     @Test
 304     public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
 305         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 306
 307         setReferencedTypeForTypeProvider(provider);
 308
 309         final Module module = resolveModule("test-type-provider-b");
 310
 311         final QName leafNode = QName.create(module.getQNameModule(), "enum");
 312         final DataSchemaNode enumNode = module.getDataChildByName(leafNode);
 313         assertNotNull("leaf enum is not present in root of module " + module.getName(), enumNode);
 314         assertTrue(enumNode instanceof LeafSchemaNode);
 315         final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
 316         final TypeDefinition<?> leafType = leaf.getType();
 317
 318         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 319         assertNotNull(leafrefResolvedType1);
 320         assertTrue(leafrefResolvedType1 instanceof ReferencedTypeImpl);
 321
 322         final QName leafListNode = QName.create(module.getQNameModule(), "enums");
 323         final DataSchemaNode enumListNode = module.getDataChildByName(leafListNode);
 324         assertNotNull("leaf-list enums is not present in root of module " + module.getName(), enumNode);
 325         assertTrue(enumListNode instanceof LeafListSchemaNode);
 326         final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
 327         final TypeDefinition<?> leafListType = leafList.getType();
 328
 329         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
 330         assertNotNull(leafrefResolvedType2);
 331         assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
 332     }
 333
 334     private void setReferencedTypeForTypeProvider(final TypeProvider provider) {
 335         final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
 336             "resolve-direct-use-of-enum");
 337         final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
 338         Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
 339
 340         Type refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getName());
 341         ((TypeProviderImpl) provider).putReferencedType(enumLeafNode.getPath(), refType);
 342
 343         final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(this.testTypeProviderModule,
 344             "foo", "list-of-enums");
 345         final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
 346         enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
 347
 348         refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getPackageName());
 349         ((TypeProviderImpl) provider).putReferencedType(enumListNode.getPath(), refType);
 350     }
 351
 352     @Test
 353     public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
 354         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 355         final Module module = resolveModule("test-type-provider-b");
 356
 357         final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
 358         final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
 359         assertNotNull("leaf conditional-leafref is not present in root of module "+ module.getName(), condLeaf);
 360         assertTrue(condLeaf instanceof LeafSchemaNode);
 361         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 362         final TypeDefinition<?> leafType = leaf.getType();
 363
 364         final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 365         assertNotNull(resultType);
 366         assertTrue(resultType instanceof ConcreteType);
 367         assertEquals("java.lang", resultType.getPackageName());
 368         assertEquals("Object", resultType.getName());
 369     }
 370
 371     @Test(expected = IllegalArgumentException.class)
 372     public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
 373         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 374         final Module module = resolveModule("test-type-provider-b");
 375
 376         final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
 377         final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
 378         assertNotNull("leaf unreslovable-leafref is not present in root of module "+ module.getName(), condLeaf);
 379         assertTrue(condLeaf instanceof LeafSchemaNode);
 380         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 381         final TypeDefinition<?> leafType = leaf.getType();
 382
 383         provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 384     }
 385
 386     @Test(expected = IllegalArgumentException.class)
 387     public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
 388         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 389
 390         provider.provideTypeForLeafref(null, null);
 391     }
 392
 393     @Test(expected = IllegalArgumentException.class)
 394     public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
 395         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 396
 397         final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
 398         provider.provideTypeForLeafref(leafrePath, this.schemaNode);
 399     }
 400
 401     @Test(expected = IllegalStateException.class)
 402     public void provideTypeForLeafrefWithNullParentModuleTest() {
 403         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 404         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "bar", "leafref-value");
 405         final TypeDefinition<?> leafType = leaf.getType();
 406         assertTrue(leafType instanceof LeafrefTypeDefinition);
 407         doReturn(null).when(this.schemaNode).getPath();
 408         provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, this.schemaNode);
 409     }
 410
 411     @Test
 412     public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
 413         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 414         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "crypto");
 415         final TypeDefinition<?> leafType = leaf.getType();
 416
 417         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 418         assertNotNull(result);
 419         assertTrue(result instanceof ParameterizedType);
 420     }
 421
 422     @Test
 423     public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
 424         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 425         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "simple-int-types-union");
 426         final TypeDefinition<?> leafType = leaf.getType();
 427
 428         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 429         assertNotNull(result);
 430         assertTrue(result instanceof GeneratedTransferObject);
 431         assertEquals("YangUnion", result.getName());
 432         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 433     }
 434
 435     @Test
 436     public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
 437         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 438         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-union");
 439         final TypeDefinition<?> leafType = leaf.getType();
 440
 441         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 442         assertNotNull(result);
 443         assertTrue(result instanceof GeneratedTransferObject);
 444         assertEquals("ComplexUnion", result.getName());
 445         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 446     }
 447
 448     @Test
 449     public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
 450         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 451         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-string-int-union");
 452         final TypeDefinition<?> leafType = leaf.getType();
 453
 454         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 455         assertNotNull(result);
 456         assertTrue(result instanceof GeneratedTransferObject);
 457         assertEquals("ComplexStringIntUnion", result.getName());
 458         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 459     }
 460
 461     @Test
 462     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
 463         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 464
 465         final Module testTypeProvider = resolveModule("test-type-provider");
 466         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-union");
 467
 468         assertNotNull(unionTypeDef);
 469         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 470         GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
 471             (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexUnionType", unionTypeDef);
 472
 473         assertNotNull(unionTypeBuilder);
 474
 475         GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
 476         assertEquals("ComplexUnionType", unionType.getName());
 477
 478         unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
 479             (UnionTypeDefinition)unionTypeDef.getBaseType(), "", unionTypeDef);
 480
 481         assertNotNull(unionTypeBuilder);
 482
 483         unionType = unionTypeBuilder.toInstance();
 484         assertEquals("Union", unionType.getName());
 485
 486         unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
 487             (UnionTypeDefinition)unionTypeDef.getBaseType(), null, unionTypeDef);
 488
 489         assertNotNull(unionTypeBuilder);
 490
 491         unionType = unionTypeBuilder.toInstance();
 492         assertEquals("Union", unionType.getName());
 493     }
 494
 495     @Test
 496     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
 497         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 498
 499         final Module testTypeProvider = resolveModule("test-type-provider");
 500         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-string-int-union");
 501
 502         assertNotNull(unionTypeDef);
 503         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 504         final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
 505             (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexStringIntUnionType", unionTypeDef);
 506
 507         assertNotNull(unionTypeBuilder);
 508
 509         final GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
 510         assertEquals("ComplexStringIntUnionType", unionType.getName());
 511     }
 512
 513     @Test
 514     public void generatedTypeForExtendedDefinitionTypeTest() {
 515         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 516
 517         final Module baseYangTypes = resolveModule("base-yang-types");
 518         final Set<TypeDefinition<?>> typeDefs = baseYangTypes.getTypeDefinitions();
 519
 520         Type yangBoolean = null;
 521         Type yangEmpty = null;
 522         Type yangEnumeration = null;
 523         Type yangInt8 = null;
 524         Type yangInt8Restricted = null;
 525         Type yangInt16 = null;
 526         Type yangInt32 = null;
 527         Type yangInt64 = null;
 528         Type yangString = null;
 529         Type yangDecimal = null;
 530         Type yangUint8 = null;
 531         Type yangUint16 = null;
 532         Type yangUint32 = null;
 533         Type yangUint64 = null;
 534         Type yangUnion = null;
 535         Type yangBinary = null;
 536         Type yangBits = null;
 537         Type yangInstanceIdentifier = null;
 538
 539         for (final TypeDefinition<?> typedef : typeDefs) {
 540             final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
 541             if (type instanceof GeneratedTransferObject) {
 542                 if (type.getName().equals("YangBoolean")) {
 543                     yangBoolean = type;
 544                 } else if (type.getName().equals("YangEmpty")) {
 545                     yangEmpty = type;
 546                 } else if (type.getName().equals("YangInt8")) {
 547                     yangInt8 = type;
 548                 } else if (type.getName().equals("YangInt8Restricted")) {
 549                     yangInt8Restricted = type;
 550                 } else if (type.getName().equals("YangInt16")) {
 551                     yangInt16 = type;
 552                 } else if (type.getName().equals("YangInt32")) {
 553                     yangInt32 = type;
 554                 } else if (type.getName().equals("YangInt64")) {
 555                     yangInt64 = type;
 556                 } else if (type.getName().equals("YangString")) {
 557                     yangString = type;
 558                 } else if (type.getName().equals("YangDecimal64")) {
 559                     yangDecimal = type;
 560                 } else if (type.getName().equals("YangUint8")) {
 561                     yangUint8 = type;
 562                 } else if (type.getName().equals("YangUint16")) {
 563                     yangUint16 = type;
 564                 } else if (type.getName().equals("YangUint32")) {
 565                     yangUint32 = type;
 566                 } else if (type.getName().equals("YangUint64")) {
 567                     yangUint64 = type;
 568                 } else if (type.getName().equals("YangUnion")) {
 569                     yangUnion = type;
 570                 } else if (type.getName().equals("YangBinary")) {
 571                     yangBinary = type;
 572                 } else if (type.getName().equals("YangInstanceIdentifier")) {
 573                     yangInstanceIdentifier = type;
 574                 } else if (type.getName().equals("YangBits")) {
 575                     yangBits = type;
 576                 }
 577             } else if (type instanceof Enumeration) {
 578                 if (type.getName().equals("YangEnumeration")) {
 579                     yangEnumeration = type;
 580                 }
 581             }
 582         }
 583
 584         assertNotNull(yangBoolean);
 585         assertNotNull(yangEmpty);
 586         assertNotNull(yangEnumeration);
 587         assertNotNull(yangInt8);
 588         assertNotNull(yangInt8Restricted);
 589         assertNotNull(yangInt16);
 590         assertNotNull(yangInt32);
 591         assertNotNull(yangInt64);
 592         assertNotNull(yangString);
 593         assertNotNull(yangDecimal);
 594         assertNotNull(yangUint8);
 595         assertNotNull(yangUint16);
 596         assertNotNull(yangUint32);
 597         assertNotNull(yangUint64);
 598         assertNotNull(yangUnion);
 599         assertNotNull(yangBinary);
 600         assertNotNull(yangBits);
 601         assertNotNull(yangInstanceIdentifier);
 602     }
 603
 604     @Test(expected = IllegalArgumentException.class)
 605     public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
 606         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 607         provider.generatedTypeForExtendedDefinitionType(null, null);
 608     }
 609
 610     @Test(expected = IllegalArgumentException.class)
 611     public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
 612         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 613         final TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
 614         provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
 615     }
 616
 617     @Test
 618     public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
 619         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 620
 621         final Module baseYangTypes = resolveModule("test-type-provider");
 622         final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes, "extended-yang-int8");
 623         assertNotNull(extYangInt8Typedef);
 624         final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
 625         assertNotNull(extType);
 626         assertTrue(extType instanceof GeneratedTransferObject);
 627     }
 628
 629     @Test
 630     public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
 631         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 632
 633         final Module baseYangTypes = resolveModule("test-type-provider");
 634         final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes, "bar-item-leafref-id");
 635         assertNotNull(barItemLeafrefId);
 636         final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
 637         assertEquals(null, extType);
 638     }
 639
 640     @Test
 641     public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
 642         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 643
 644         final Module baseYangTypes = resolveModule("test-type-provider");
 645
 646         final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes, "aes-identityref-type");
 647
 648         assertNotNull(aesIdentityrefType);
 649         final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
 650         assertEquals(null, extType);
 651     }
 652
 653     @Test(expected = IllegalArgumentException.class)
 654     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
 655         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 656         provider.provideGeneratedTOBuilderForBitsTypeDefinition("", null, "", "");
 657     }
 658
 659     @Test(expected = IllegalArgumentException.class)
 660     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithBasePackageNullTest() {
 661         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 662         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 663         final TypeDefinition<?> leafType = leaf.getType();
 664         provider.provideGeneratedTOBuilderForBitsTypeDefinition(null, leafType, "", "");
 665     }
 666
 667     @Test
 668     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNonBitsTypedefTest() {
 669         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 670
 671         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 672         final TypeDefinition<?> leafType = leaf.getType();
 673         final Type type = provider.provideGeneratedTOBuilderForBitsTypeDefinition("", leafType, "", "");
 674
 675         assertEquals(null, type);
 676     }
 677
 678     @Test
 679     public void getConstructorPropertyNameTest() {
 680         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 681
 682         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 683         final TypeDefinition<?> leafType = leaf.getType();
 684
 685         final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
 686         assertEquals("value", ctorPropertyName);
 687
 688         final String emptyStringName = provider.getConstructorPropertyName(leaf);
 689         assertTrue(emptyStringName.isEmpty());
 690     }
 691
 692     @Test
 693     public void getParamNameFromTypeTest() {
 694         final TypeProvider provider = new TypeProviderImpl(this.schemaContext);
 695
 696         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
 697         final TypeDefinition<?> leafType = leaf.getType();
 698
 699         final String paramName = provider.getParamNameFromType(leafType);
 700         assertEquals("yangInt8", paramName);
 701     }
 702
 703     @Test
 704     public void addUnitsToGenTOTest() {
 705         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 706
 707         final GeneratedTOBuilder builder = new GeneratedTOBuilderImpl("test.package", "TestBuilder");
 708
 709         TypeProviderImpl.addUnitsToGenTO(builder, null);
 710         GeneratedTransferObject genTO = builder.toInstance();
 711         assertTrue(genTO.getConstantDefinitions().isEmpty());
 712
 713         TypeProviderImpl.addUnitsToGenTO(builder, "");
 714         genTO = builder.toInstance();
 715         assertTrue(genTO.getConstantDefinitions().isEmpty());
 716
 717         TypeProviderImpl.addUnitsToGenTO(builder, "125");
 718         genTO = builder.toInstance();
 719         assertTrue(!genTO.getConstantDefinitions().isEmpty());
 720         assertEquals(1, genTO.getConstantDefinitions().size());
 721         assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
 722         assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
 723     }
 724
 725     @Test(expected = NullPointerException.class)
 726     public void getTypeDefaultConstructionLeafTypeNullTest() {
 727         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 728         final TestLeafSchemaNode leafSchemaNode = new TestLeafSchemaNode();
 729         provider.getTypeDefaultConstruction(leafSchemaNode, null);
 730     }
 731
 732     @Test(expected = NullPointerException.class)
 733     public void getTypeDefaultConstructionDefaultValueNullTest() {
 734         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 735         final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
 736         provider.getTypeDefaultConstruction(leaf, null);
 737     }
 738
 739     private LeafSchemaNode provideLeafForGetDefaultConstructionTestCase(final String leafName) {
 740         return provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "construction-type-test",
 741             leafName);
 742     }
 743
 744     @Test(expected = UnsupportedOperationException.class)
 745     public void getTypeDefaultConstructionDefaultValueForInstanceIdentifierTest() {
 746         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 747         final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("foo-container-id");
 748         provider.getTypeDefaultConstruction(leaf, "NAN");
 749     }
 750
 751     @Test(expected = UnsupportedOperationException.class)
 752     public void getTypeDefaultConstructionDefaultValueForIdentityrefTest() {
 753         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 754         final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("aes-identityref-type");
 755         provider.getTypeDefaultConstruction(leaf, "NAN");
 756     }
 757
 758     @Test
 759     public void getTypeDefaultConstructionDefaultValueTest() {
 760         final TypeProviderImpl provider = new TypeProviderImpl(this.schemaContext);
 761
 762         LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
 763         String result = provider.getTypeDefaultConstruction(leaf, "true");
 764         assertNotNull(result);
 765         assertTrue(!result.isEmpty());
 766         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBoolean(java.lang.Boolean.TRUE)",
 767             result);
 768
 769         leaf = provideLeafForGetDefaultConstructionTestCase("yang-empty");
 770         result = provider.getTypeDefaultConstruction(leaf, "true");
 771         assertNotNull(result);
 772         assertTrue(!result.isEmpty());
 773         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEmpty(java.lang.Boolean.TRUE)",
 774             result);
 775
 776         leaf = provideLeafForGetDefaultConstructionTestCase("yang-enumeration");
 777         result = provider.getTypeDefaultConstruction(leaf, "a");
 778         assertNotNull(result);
 779         assertTrue(!result.isEmpty());
 780         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEnumeration.A",
 781             result);
 782
 783         leaf = provideLeafForGetDefaultConstructionTestCase("direct-use-of-enum");
 784         result = provider.getTypeDefaultConstruction(leaf, "y");
 785         assertNotNull(result);
 786         assertTrue(!result.isEmpty());
 787         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.construction.type.test.DirectUseOfEnum.Y",
 788             result);
 789
 790         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8");
 791         result = provider.getTypeDefaultConstruction(leaf, "17");
 792         assertNotNull(result);
 793         assertTrue(!result.isEmpty());
 794         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"17\"))",
 795             result);
 796
 797         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8-restricted");
 798         result = provider.getTypeDefaultConstruction(leaf, "99");
 799         assertNotNull(result);
 800         assertTrue(!result.isEmpty());
 801         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8Restricted(java.lang.Byte.valueOf(\"99\"))",
 802             result);
 803
 804         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int16");
 805         result = provider.getTypeDefaultConstruction(leaf, "1024");
 806         assertNotNull(result);
 807         assertTrue(!result.isEmpty());
 808         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"1024\"))",
 809             result);
 810
 811         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int32");
 812         result = provider.getTypeDefaultConstruction(leaf, "1048576");
 813         assertNotNull(result);
 814         assertTrue(!result.isEmpty());
 815         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt32(java.lang.Integer.valueOf(\"1048576\"))",
 816             result);
 817
 818         leaf = provideLeafForGetDefaultConstructionTestCase("yang-int64");
 819         result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
 820         assertNotNull(result);
 821         assertTrue(!result.isEmpty());
 822         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt64(java.lang.Long.valueOf(\"1099511627776\"))",
 823             result);
 824
 825         leaf = provideLeafForGetDefaultConstructionTestCase("yang-string");
 826         result = provider.getTypeDefaultConstruction(leaf, "TEST");
 827         assertNotNull(result);
 828         assertTrue(!result.isEmpty());
 829         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangString(\"TEST\")",
 830             result);
 831
 832         leaf = provideLeafForGetDefaultConstructionTestCase("yang-decimal64");
 833         result = provider.getTypeDefaultConstruction(leaf, "1274.25");
 834         assertNotNull(result);
 835         assertTrue(!result.isEmpty());
 836         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangDecimal64(new java.math.BigDecimal(\"1274.25\"))",
 837             result);
 838
 839         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint8");
 840         result = provider.getTypeDefaultConstruction(leaf, "128");
 841         assertNotNull(result);
 842         assertTrue(!result.isEmpty());
 843         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint8(java.lang.Short.valueOf(\"128\"))",
 844             result);
 845
 846         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint16");
 847         result = provider.getTypeDefaultConstruction(leaf, "1048576");
 848         assertNotNull(result);
 849         assertTrue(!result.isEmpty());
 850         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint16(java.lang.Integer.valueOf(\"1048576\"))",
 851             result);
 852
 853         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint32");
 854         result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
 855         assertNotNull(result);
 856         assertTrue(!result.isEmpty());
 857         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint32(java.lang.Long.valueOf(\"1099511627776\"))",
 858             result);
 859
 860         leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint64");
 861         result = provider.getTypeDefaultConstruction(leaf, "1208925819614629174706176");
 862         assertNotNull(result);
 863         assertTrue(!result.isEmpty());
 864         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint64(new java.math.BigInteger(\"1208925819614629174706176\"))",
 865             result);
 866
 867         //FIXME: Is this correct scenario and correct result?
 868         leaf = provideLeafForGetDefaultConstructionTestCase("complex-union");
 869         result = provider.getTypeDefaultConstruction(leaf, "75");
 870         assertNotNull(result);
 871         assertTrue(!result.isEmpty());
 872         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexUnion(\"null\".toCharArray())",
 873             result);
 874
 875         //FIXME: Is this correct scenario and correct result?
 876         leaf = provideLeafForGetDefaultConstructionTestCase("complex-string-int-union");
 877         result = provider.getTypeDefaultConstruction(leaf, "TEST_UNION_STRING_DEFAULT");
 878         assertNotNull(result);
 879         assertTrue(!result.isEmpty());
 880         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexStringIntUnion(\"null\".toCharArray())",
 881             result);
 882
 883         leaf = provideLeafForGetDefaultConstructionTestCase("simple-int-types-union");
 884         result = provider.getTypeDefaultConstruction(leaf, "2048");
 885         assertNotNull(result);
 886         assertTrue(!result.isEmpty());
 887         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUnion(\"null\".toCharArray())",
 888             result);
 889
 890
 891         leaf = provideLeafForGetDefaultConstructionTestCase("direct-union-leaf");
 892         result = provider.getTypeDefaultConstruction(leaf);
 893         assertNotNull(result);
 894         assertTrue(!result.isEmpty());
 895         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.DirectUnionLeaf(\"128\".toCharArray())",
 896             result);
 897
 898         final Module module = resolveModule("test-type-provider");
 899         final QName leafUnionNode = QName.create(module.getQNameModule(), "root-union-leaf");
 900         DataSchemaNode rootNode = module.getDataChildByName(leafUnionNode);
 901         assertNotNull("leaf root-union-leaf is not present in root of module "+ module.getName(), rootNode);
 902         assertTrue(rootNode instanceof LeafSchemaNode);
 903         leaf = (LeafSchemaNode) rootNode;
 904         result = provider.getTypeDefaultConstruction(leaf);
 905         assertNotNull(result);
 906         assertTrue(!result.isEmpty());
 907         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootUnionLeaf(\"256\".toCharArray())",
 908             result);
 909
 910         leaf = provideLeafForGetDefaultConstructionTestCase("yang-binary");
 911         result = provider.getTypeDefaultConstruction(leaf, "0xffffff");
 912         assertNotNull(result);
 913         assertTrue(!result.isEmpty());
 914         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBinary(new byte[] {-45, 23, -33, 125, -9, -33})",
 915             result);
 916
 917         final QName leafBitsNode = QName.create(module.getQNameModule(), "root-bits-leaf");
 918         rootNode = module.getDataChildByName(leafBitsNode);
 919         assertNotNull("leaf bits-leaf is not present in root of module "+ module.getName(), rootNode);
 920         assertTrue(rootNode instanceof LeafSchemaNode);
 921         leaf = (LeafSchemaNode) rootNode;
 922         result = provider.getTypeDefaultConstruction(leaf);
 923         assertNotNull(result);
 924         assertTrue(!result.isEmpty());
 925         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootBitsLeaf(false, true, false)",
 926             result);
 927
 928         leaf = provideLeafForGetDefaultConstructionTestCase("yang-bits");
 929         result = provider.getTypeDefaultConstruction(leaf, "10-Mb-only");
 930         assertNotNull(result);
 931         assertTrue(!result.isEmpty());
 932         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBits(true, false, false)",
 933             result);
 934
 935         leaf = provideLeafForGetDefaultConstructionTestCase("bar-id");
 936         result = provider.getTypeDefaultConstruction(leaf, "128");
 937         assertNotNull(result);
 938         assertTrue(!result.isEmpty());
 939         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"128\"))",
 940             result);
 941
 942         leaf = provideLeafForGetDefaultConstructionTestCase("foo-leafref-value");
 943         result = provider.getTypeDefaultConstruction(leaf, "32");
 944         assertNotNull(result);
 945         assertTrue(!result.isEmpty());
 946         assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"32\"))",
 947             result);
 948
 949         leaf = provideLeafForGetDefaultConstructionTestCase("foo-cond-bar-item");
 950         result = provider.getTypeDefaultConstruction(leaf, "10");
 951         assertNotNull(result);
 952         assertTrue(!result.isEmpty());
 953         assertEquals("new java.lang.Object()",
 954             result);
 955     }
 956 }