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