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

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