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