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

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