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

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