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

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