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

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