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