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