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

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