binding/mdsal-binding-generator/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
  14 import com.google.common.collect.Range;
  15 import java.util.List;
  16 import java.util.Optional;
  17 import org.junit.AfterClass;
  18 import org.junit.BeforeClass;
  19 import org.junit.Ignore;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.Mock;
  23 import org.mockito.junit.MockitoJUnitRunner;
  24 import org.opendaylight.mdsal.binding.generator.BindingGeneratorUtil;
  25 import org.opendaylight.mdsal.binding.model.api.ConcreteType;
  26 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  27 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  28 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  29 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
  30 import org.opendaylight.mdsal.binding.model.api.Restrictions;
  31 import org.opendaylight.mdsal.binding.model.api.Type;
  32 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
  33 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
  34 import org.opendaylight.yangtools.yang.common.QName;
  35 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  36 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  37 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  38 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  40 import org.opendaylight.yangtools.yang.model.api.Module;
  41 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  42 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  43 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  44 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  45 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  46 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  47
  48 /**
  49  * Test suite for testing public methods in TypeProviderImpl class.
  50  *
  51  * @see org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider
  52  * @author Lukas Sedlak &lt;lsedlak@cisco.com&gt;
  53  */
  54 // FIXME: rewrite tests without TypeProvider interface
  55 @Ignore
  56 @RunWith(MockitoJUnitRunner.class)
  57 public class TypeProviderTest {
  58     static EffectiveModelContext SCHEMA_CONTEXT;
  59     static Module TEST_TYPE_PROVIDER;
  60
  61     @Mock
  62     public SchemaPath schemaPath;
  63
  64     @Mock
  65     public SchemaNode schemaNode;
  66
  67     @BeforeClass
  68     public static void beforeClass() {
  69         SCHEMA_CONTEXT = YangParserTestUtils.parseYangResources(TypeProviderTest.class,
  70             "/base-yang-types.yang", "/test-type-provider-b.yang", "/test-type-provider.yang");
  71         TEST_TYPE_PROVIDER = resolveModule("test-type-provider");
  72     }
  73
  74     @AfterClass
  75     public static void afterClass() {
  76         TEST_TYPE_PROVIDER = null;
  77         SCHEMA_CONTEXT = null;
  78     }
  79
  80     private static Module resolveModule(final String moduleName) {
  81         return SCHEMA_CONTEXT.findModules(moduleName).iterator().next();
  82     }
  83
  84     private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName,
  85             final String leafNodeName) {
  86         final QName containerNode = QName.create(module.getQNameModule(), containerName);
  87         final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get();
  88         assertTrue(rootNode instanceof DataNodeContainer);
  89
  90         final QName leafNode = QName.create(module.getQNameModule(), leafNodeName);
  91         final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
  92         final DataSchemaNode node = rootContainer.findDataChildByName(leafNode).get();
  93         assertTrue(node instanceof LeafSchemaNode);
  94         return (LeafSchemaNode) node;
  95     }
  96
  97     private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module,
  98             final String containerName, final String leafListNodeName) {
  99         final QName containerNode = QName.create(module.getQNameModule(), containerName);
 100         final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get();
 101         assertTrue(rootNode instanceof DataNodeContainer);
 102
 103         final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
 104         final QName leafListNode = QName.create(module.getQNameModule(), leafListNodeName);
 105         final DataSchemaNode node = rootContainer.findDataChildByName(leafListNode).get();
 106         assertTrue(node instanceof LeafListSchemaNode);
 107         return (LeafListSchemaNode) node;
 108     }
 109
 110     @Test
 111     public void javaTypeForSchemaDefinitionExtTypeTest() {
 112         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 113         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 114             "yang-int8-type");
 115
 116         final TypeDefinition<?> leafType = leaf.getType();
 117         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 118         assertNotNull(result);
 119         assertTrue(result instanceof GeneratedTransferObject);
 120
 121         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 122         assertEquals("base-yang-types", genTO.getModuleName());
 123         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
 124             genTO.getPackageName());
 125         assertEquals("YangInt8", genTO.getName());
 126         assertEquals(1, genTO.getProperties().size());
 127     }
 128
 129     @Test
 130     public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
 131         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 132         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 133             "restricted-int8-type");
 134
 135         final TypeDefinition<?> leafType = leaf.getType();
 136         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 137
 138         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 139         assertNotNull(result);
 140         assertTrue(result instanceof GeneratedTransferObject);
 141
 142         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 143         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
 144             genTO.getPackageName());
 145         assertEquals("YangInt8Restricted", genTO.getName());
 146         assertEquals(1, genTO.getProperties().size());
 147         final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
 148
 149         assertTrue(rangeConstraints.isPresent());
 150         final Range<?> constraint = rangeConstraints.get().getAllowedRanges().asRanges().iterator().next();
 151         assertEquals((byte) 1, constraint.lowerEndpoint());
 152         assertEquals((byte) 100, constraint.upperEndpoint());
 153     }
 154
 155     @Test
 156     public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
 157         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 158
 159         final Module testTypeProvider = resolveModule("test-type-provider");
 160         final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider,
 161             "empty-pattern-string");
 162
 163         assertNotNull(emptyPatternString);
 164         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
 165
 166         Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
 167         assertNotNull(result);
 168         assertTrue(result instanceof GeneratedTransferObject);
 169
 170         result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
 171         assertNotNull(result);
 172         assertTrue(result instanceof GeneratedTransferObject);
 173     }
 174
 175     private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
 176         TypeDefinition<?> result = null;
 177         for (final TypeDefinition<?> typedef : module.getTypeDefinitions()) {
 178             if (typedef.getQName().getLocalName().equals(typedefName)) {
 179                 result = typedef;
 180             }
 181         }
 182         return result;
 183     }
 184
 185     @Test
 186     public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
 187         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 188         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-enum-leaf");
 189         TypeDefinition<?> leafType = leaf.getType();
 190         Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 191         assertNotNull(result);
 192         assertTrue(result instanceof Enumeration);
 193
 194         final Enumeration enumType = (Enumeration) result;
 195         final List<Enumeration.Pair> enumValues = enumType.getValues();
 196         assertTrue(!enumValues.isEmpty());
 197         assertEquals("a", enumValues.get(0).getName());
 198         assertEquals("b", enumValues.get(1).getName());
 199         assertEquals("A", enumValues.get(0).getMappedName());
 200         assertEquals("B", enumValues.get(1).getMappedName());
 201
 202         leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-direct-use-of-enum");
 203         leafType = leaf.getType();
 204         result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 205         assertNotNull(result);
 206         assertTrue(result instanceof ConcreteType);
 207
 208         assertEquals("java.lang", result.getPackageName());
 209         assertEquals("Enum", result.getName());
 210     }
 211
 212     @Test
 213     public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
 214         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 215         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar", "leafref-value");
 216         TypeDefinition<?> leafType = leaf.getType();
 217         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 218         assertNotNull(leafrefResolvedType1);
 219         assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
 220
 221         final Module module = resolveModule("test-type-provider-b");
 222         final QName leafNode = QName.create(module.getQNameModule(), "id");
 223         final DataSchemaNode rootNode = module.findDataChildByName(leafNode).get();
 224         assertNotNull("leaf id is not present in root of module " + module.getName(), rootNode);
 225         assertTrue(rootNode instanceof LeafSchemaNode);
 226         leaf = (LeafSchemaNode) rootNode;
 227         leafType = leaf.getType();
 228
 229         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 230         assertNotNull(leafrefResolvedType2);
 231         assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
 232     }
 233
 234     @Test
 235     public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
 236         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 237         final Module module = resolveModule("test-type-provider-b");
 238
 239         final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
 240         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 241         assertTrue(condLeaf instanceof LeafSchemaNode);
 242         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 243         final TypeDefinition<?> leafType = leaf.getType();
 244
 245         final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 246         assertNotNull(resultType);
 247         assertTrue(resultType instanceof ConcreteType);
 248         assertEquals("java.lang", resultType.getPackageName());
 249         assertEquals("Object", resultType.getName());
 250     }
 251
 252     @Test(expected = IllegalArgumentException.class)
 253     public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
 254         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 255         final Module module = resolveModule("test-type-provider-b");
 256
 257         final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
 258         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 259         assertTrue(condLeaf instanceof LeafSchemaNode);
 260         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 261         final TypeDefinition<?> leafType = leaf.getType();
 262
 263         provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 264     }
 265
 266     @Test
 267     public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
 268         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 269         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "crypto");
 270         final TypeDefinition<?> leafType = leaf.getType();
 271
 272         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 273         assertNotNull(result);
 274         assertTrue(result instanceof ParameterizedType);
 275     }
 276
 277     @Test
 278     public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
 279         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 280         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 281             "simple-int-types-union");
 282         final TypeDefinition<?> leafType = leaf.getType();
 283
 284         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 285         assertNotNull(result);
 286         assertTrue(result instanceof GeneratedTransferObject);
 287         assertEquals("YangUnion", result.getName());
 288         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 289     }
 290
 291     @Test
 292     public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
 293         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 294         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 295             "complex-union");
 296         final TypeDefinition<?> leafType = leaf.getType();
 297
 298         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 299         assertNotNull(result);
 300         assertTrue(result instanceof GeneratedTransferObject);
 301         assertEquals("ComplexUnion", result.getName());
 302         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 303     }
 304
 305     @Test
 306     public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
 307         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 308         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 309             "complex-string-int-union");
 310         final TypeDefinition<?> leafType = leaf.getType();
 311
 312         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 313         assertNotNull(result);
 314         assertTrue(result instanceof GeneratedTransferObject);
 315         assertEquals("ComplexStringIntUnion", result.getName());
 316         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 317     }
 318
 319     @Test
 320     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
 321         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 322
 323         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER, "complex-union");
 324
 325         assertNotNull(unionTypeDef);
 326         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 327         GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
 328             JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
 329             (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
 330
 331         assertNotNull(unionTypeBuilder);
 332
 333         GeneratedTransferObject unionType = unionTypeBuilder.build();
 334         assertEquals("ComplexUnion", unionType.getName());
 335     }
 336
 337     @Test
 338     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
 339         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 340
 341         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER,
 342             "complex-string-int-union");
 343
 344         assertNotNull(unionTypeDef);
 345         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 346         final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
 347             JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
 348             (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
 349
 350         assertNotNull(unionTypeBuilder);
 351
 352         final GeneratedTransferObject unionType = unionTypeBuilder.build();
 353         assertEquals("ComplexStringIntUnion", unionType.getName());
 354     }
 355
 356     @Test
 357     public void generatedTypeForExtendedDefinitionTypeTest() {
 358         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 359
 360         final Module baseYangTypes = resolveModule("base-yang-types");
 361
 362         Type yangBoolean = null;
 363         Type yangEmpty = null;
 364         Type yangEnumeration = null;
 365         Type yangInt8 = null;
 366         Type yangInt8Restricted = null;
 367         Type yangInt16 = null;
 368         Type yangInt32 = null;
 369         Type yangInt64 = null;
 370         Type yangString = null;
 371         Type yangDecimal = null;
 372         Type yangUint8 = null;
 373         Type yangUint16 = null;
 374         Type yangUint32 = null;
 375         Type yangUint64 = null;
 376         Type yangUnion = null;
 377         Type yangBinary = null;
 378         Type yangBits = null;
 379         Type yangInstanceIdentifier = null;
 380
 381         for (final TypeDefinition<?> typedef : baseYangTypes.getTypeDefinitions()) {
 382             final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
 383             if (type instanceof GeneratedTransferObject) {
 384                 if (type.getName().equals("YangBoolean")) {
 385                     yangBoolean = type;
 386                 } else if (type.getName().equals("YangEmpty")) {
 387                     yangEmpty = type;
 388                 } else if (type.getName().equals("YangInt8")) {
 389                     yangInt8 = type;
 390                 } else if (type.getName().equals("YangInt8Restricted")) {
 391                     yangInt8Restricted = type;
 392                 } else if (type.getName().equals("YangInt16")) {
 393                     yangInt16 = type;
 394                 } else if (type.getName().equals("YangInt32")) {
 395                     yangInt32 = type;
 396                 } else if (type.getName().equals("YangInt64")) {
 397                     yangInt64 = type;
 398                 } else if (type.getName().equals("YangString")) {
 399                     yangString = type;
 400                 } else if (type.getName().equals("YangDecimal64")) {
 401                     yangDecimal = type;
 402                 } else if (type.getName().equals("YangUint8")) {
 403                     yangUint8 = type;
 404                 } else if (type.getName().equals("YangUint16")) {
 405                     yangUint16 = type;
 406                 } else if (type.getName().equals("YangUint32")) {
 407                     yangUint32 = type;
 408                 } else if (type.getName().equals("YangUint64")) {
 409                     yangUint64 = type;
 410                 } else if (type.getName().equals("YangUnion")) {
 411                     yangUnion = type;
 412                 } else if (type.getName().equals("YangBinary")) {
 413                     yangBinary = type;
 414                 } else if (type.getName().equals("YangInstanceIdentifier")) {
 415                     yangInstanceIdentifier = type;
 416                 } else if (type.getName().equals("YangBits")) {
 417                     yangBits = type;
 418                 }
 419             } else if (type instanceof Enumeration) {
 420                 if (type.getName().equals("YangEnumeration")) {
 421                     yangEnumeration = type;
 422                 }
 423             }
 424         }
 425
 426         assertNotNull(yangBoolean);
 427         assertNotNull(yangEmpty);
 428         assertNotNull(yangEnumeration);
 429         assertNotNull(yangInt8);
 430         assertNotNull(yangInt8Restricted);
 431         assertNotNull(yangInt16);
 432         assertNotNull(yangInt32);
 433         assertNotNull(yangInt64);
 434         assertNotNull(yangString);
 435         assertNotNull(yangDecimal);
 436         assertNotNull(yangUint8);
 437         assertNotNull(yangUint16);
 438         assertNotNull(yangUint32);
 439         assertNotNull(yangUint64);
 440         assertNotNull(yangUnion);
 441         assertNotNull(yangBinary);
 442         assertNotNull(yangBits);
 443         assertNotNull(yangInstanceIdentifier);
 444     }
 445
 446     @Test
 447     public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
 448         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 449
 450         final Module baseYangTypes = resolveModule("test-type-provider");
 451         final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes,
 452             "extended-yang-int8");
 453         assertNotNull(extYangInt8Typedef);
 454         final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
 455         assertNotNull(extType);
 456         assertTrue(extType instanceof GeneratedTransferObject);
 457     }
 458
 459     @Test
 460     public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
 461         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 462
 463         final Module baseYangTypes = resolveModule("test-type-provider");
 464         final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes,
 465             "bar-item-leafref-id");
 466         assertNotNull(barItemLeafrefId);
 467         final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
 468         assertEquals(null, extType);
 469     }
 470
 471     @Test
 472     public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
 473         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 474
 475         final Module baseYangTypes = resolveModule("test-type-provider");
 476
 477         final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes,
 478             "aes-identityref-type");
 479
 480         assertNotNull(aesIdentityrefType);
 481         final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
 482         assertEquals(null, extType);
 483     }
 484 }