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