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
  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.model.api.ConcreteType;
  25 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  26 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  27 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  28 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
  29 import org.opendaylight.mdsal.binding.model.api.Restrictions;
  30 import org.opendaylight.mdsal.binding.model.api.Type;
  31 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
  32 import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
  33 import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
  34 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
  35 import org.opendaylight.yangtools.yang.common.QName;
  36 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  37 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  38 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  39 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  40 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  41 import org.opendaylight.yangtools.yang.model.api.Module;
  42 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  43 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  44 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  45 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  46 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  47
  48 /**
  49  * Test suite for testing public methods in TypeProviderImpl class.
  50  *
  51  * @see org.opendaylight.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
  59     public static EffectiveModelContext SCHEMA_CONTEXT;
  60     public static Module TEST_TYPE_PROVIDER;
  61
  62     @Mock
  63     public SchemaPath schemaPath;
  64
  65     @Mock
  66     public SchemaNode schemaNode;
  67
  68     @BeforeClass
  69     public static void beforeClass() {
  70         SCHEMA_CONTEXT = TypeProviderModel.createTestContext();
  71         TEST_TYPE_PROVIDER = resolveModule(TypeProviderModel.TEST_TYPE_PROVIDER_MODULE_NAME);
  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     @Test(expected = IllegalArgumentException.class)
  85     public void typeProviderInstanceWithNullSchemaContextTest() {
  86         new RuntimeTypeProvider(null);
  87     }
  88
  89     @Test(expected = IllegalArgumentException.class)
  90     public void putReferencedTypeWithNullSchemaPathParamTest() {
  91         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
  92
  93         provider.putReferencedType(null, null);
  94         provider.putReferencedType(this.schemaPath, null);
  95     }
  96
  97     @Test(expected = IllegalArgumentException.class)
  98     public void putReferencedTypeWithNullRefTypeParamTest() {
  99         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 100
 101         provider.putReferencedType(this.schemaPath, null);
 102     }
 103
 104     @Test
 105     public void getAdditionalTypesTest() {
 106         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 107
 108         assertNotNull(provider.getAdditionalTypes());
 109     }
 110
 111     @Test(expected = IllegalArgumentException.class)
 112     public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
 113         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 114
 115         provider.javaTypeForSchemaDefinitionType(null, null, null);
 116     }
 117
 118     @Test(expected = IllegalArgumentException.class)
 119     public void javaTypeForSchemaDefinitionTypeTypedefNullQNameTest() {
 120         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 121
 122         final TestIntegerTypeDefinition testTypedef = new TestIntegerTypeDefinition();
 123         provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
 124     }
 125
 126     private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName,
 127             final String leafNodeName) {
 128         final QName containerNode = QName.create(module.getQNameModule(), containerName);
 129         final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get();
 130         assertTrue(rootNode instanceof DataNodeContainer);
 131
 132         final QName leafNode = QName.create(module.getQNameModule(), leafNodeName);
 133         final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
 134         final DataSchemaNode node = rootContainer.findDataChildByName(leafNode).get();
 135         assertTrue(node instanceof LeafSchemaNode);
 136         return (LeafSchemaNode) node;
 137     }
 138
 139     private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module,
 140             final String containerName, final String leafListNodeName) {
 141         final QName containerNode = QName.create(module.getQNameModule(), containerName);
 142         final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get();
 143         assertTrue(rootNode instanceof DataNodeContainer);
 144
 145         final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
 146         final QName leafListNode = QName.create(module.getQNameModule(), leafListNodeName);
 147         final DataSchemaNode node = rootContainer.findDataChildByName(leafListNode).get();
 148         assertTrue(node instanceof LeafListSchemaNode);
 149         return (LeafListSchemaNode) node;
 150     }
 151
 152     @Test
 153     public void javaTypeForSchemaDefinitionExtTypeTest() {
 154         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 155         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 156             "yang-int8-type");
 157
 158         final TypeDefinition<?> leafType = leaf.getType();
 159         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 160         assertNotNull(result);
 161         assertTrue(result instanceof GeneratedTransferObject);
 162
 163         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 164         assertEquals("base-yang-types", genTO.getModuleName());
 165         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
 166             genTO.getPackageName());
 167         assertEquals("YangInt8", genTO.getName());
 168         assertEquals(1, genTO.getProperties().size());
 169     }
 170
 171     @Test
 172     public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
 173         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 174         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 175             "restricted-int8-type");
 176
 177         final TypeDefinition<?> leafType = leaf.getType();
 178         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 179
 180         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 181         assertNotNull(result);
 182         assertTrue(result instanceof GeneratedTransferObject);
 183
 184         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 185         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
 186             genTO.getPackageName());
 187         assertEquals("YangInt8Restricted", genTO.getName());
 188         assertEquals(1, genTO.getProperties().size());
 189         final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
 190
 191         assertTrue(rangeConstraints.isPresent());
 192         final Range<?> constraint = rangeConstraints.get().getAllowedRanges().asRanges().iterator().next();
 193         assertEquals((byte) 1, constraint.lowerEndpoint());
 194         assertEquals((byte) 100, constraint.upperEndpoint());
 195     }
 196
 197     @Test
 198     public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
 199         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 200
 201         final Module testTypeProvider = resolveModule("test-type-provider");
 202         final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider,
 203             "empty-pattern-string");
 204
 205         assertNotNull(emptyPatternString);
 206         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
 207
 208         Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
 209         assertNotNull(result);
 210         assertTrue(result instanceof GeneratedTransferObject);
 211
 212         result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
 213         assertNotNull(result);
 214         assertTrue(result instanceof GeneratedTransferObject);
 215     }
 216
 217     private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
 218         TypeDefinition<?> result = null;
 219         for (final TypeDefinition<?> typedef : module.getTypeDefinitions()) {
 220             if (typedef.getQName().getLocalName().equals(typedefName)) {
 221                 result = typedef;
 222             }
 223         }
 224         return result;
 225     }
 226
 227     // FIXME: Remove @Ignore annotation once the bug https://bugs.opendaylight.org/show_bug.cgi?id=1862 is fixed
 228     @Ignore
 229     @Test
 230     public void bug1862RestrictedTypedefTransformationTest() {
 231         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 232         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 233             "bug-1862-restricted-typedef");
 234
 235         final TypeDefinition<?> leafType = leaf.getType();
 236         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 237         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 238         assertNotNull(result);
 239         assertTrue(result instanceof GeneratedTransferObject);
 240         //TODO: complete test after bug 1862 is fixed
 241     }
 242
 243     @Test
 244     public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
 245         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 246         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-enum-leaf");
 247         TypeDefinition<?> leafType = leaf.getType();
 248         Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 249         assertNotNull(result);
 250         assertTrue(result instanceof Enumeration);
 251
 252         final Enumeration enumType = (Enumeration) result;
 253         final List<Enumeration.Pair> enumValues = enumType.getValues();
 254         assertTrue(!enumValues.isEmpty());
 255         assertEquals("a", enumValues.get(0).getName());
 256         assertEquals("b", enumValues.get(1).getName());
 257         assertEquals("A", enumValues.get(0).getMappedName());
 258         assertEquals("B", enumValues.get(1).getMappedName());
 259
 260         leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-direct-use-of-enum");
 261         leafType = leaf.getType();
 262         result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 263         assertNotNull(result);
 264         assertTrue(result instanceof ConcreteType);
 265
 266         assertEquals("java.lang", result.getPackageName());
 267         assertEquals("Enum", result.getName());
 268     }
 269
 270     @Test
 271     public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
 272         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 273         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar", "leafref-value");
 274         TypeDefinition<?> leafType = leaf.getType();
 275         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 276         assertNotNull(leafrefResolvedType1);
 277         assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
 278
 279         final Module module = resolveModule("test-type-provider-b");
 280         final QName leafNode = QName.create(module.getQNameModule(), "id");
 281         final DataSchemaNode rootNode = module.findDataChildByName(leafNode).get();
 282         assertNotNull("leaf id is not present in root of module " + module.getName(), rootNode);
 283         assertTrue(rootNode instanceof LeafSchemaNode);
 284         leaf = (LeafSchemaNode) rootNode;
 285         leafType = leaf.getType();
 286
 287         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 288         assertNotNull(leafrefResolvedType2);
 289         assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
 290     }
 291
 292     @Test
 293     public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
 294         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 295
 296         setReferencedTypeForTypeProvider(provider);
 297
 298         final Module module = resolveModule("test-type-provider-b");
 299
 300         final QName leafNode = QName.create(module.getQNameModule(), "enum");
 301         final DataSchemaNode enumNode = module.findDataChildByName(leafNode).get();
 302         assertTrue(enumNode instanceof LeafSchemaNode);
 303         final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
 304         final TypeDefinition<?> leafType = leaf.getType();
 305
 306         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 307         assertNotNull(leafrefResolvedType1);
 308
 309         final QName leafListNode = QName.create(module.getQNameModule(), "enums");
 310         final DataSchemaNode enumListNode = module.findDataChildByName(leafListNode).get();
 311         assertTrue(enumListNode instanceof LeafListSchemaNode);
 312         final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
 313         final TypeDefinition<?> leafListType = leafList.getType();
 314
 315         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
 316         assertNotNull(leafrefResolvedType2);
 317         assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
 318     }
 319
 320     private static void setReferencedTypeForTypeProvider(final AbstractTypeProvider provider) {
 321         final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 322             "resolve-direct-use-of-enum");
 323         final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
 324         provider.putReferencedType(enumLeafNode.getPath(),
 325             Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode)));
 326
 327         final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(TEST_TYPE_PROVIDER,
 328             "foo", "list-of-enums");
 329         final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
 330         provider.putReferencedType(enumListNode.getPath(),
 331             Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode)));
 332     }
 333
 334     @Test
 335     public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
 336         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 337         final Module module = resolveModule("test-type-provider-b");
 338
 339         final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
 340         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 341         assertTrue(condLeaf instanceof LeafSchemaNode);
 342         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 343         final TypeDefinition<?> leafType = leaf.getType();
 344
 345         final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 346         assertNotNull(resultType);
 347         assertTrue(resultType instanceof ConcreteType);
 348         assertEquals("java.lang", resultType.getPackageName());
 349         assertEquals("Object", resultType.getName());
 350     }
 351
 352     @Test(expected = IllegalArgumentException.class)
 353     public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
 354         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 355         final Module module = resolveModule("test-type-provider-b");
 356
 357         final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
 358         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 359         assertTrue(condLeaf instanceof LeafSchemaNode);
 360         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 361         final TypeDefinition<?> leafType = leaf.getType();
 362
 363         provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 364     }
 365
 366     @Test
 367     public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
 368         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 369         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "crypto");
 370         final TypeDefinition<?> leafType = leaf.getType();
 371
 372         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 373         assertNotNull(result);
 374         assertTrue(result instanceof ParameterizedType);
 375     }
 376
 377     @Test
 378     public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
 379         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 380         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 381             "simple-int-types-union");
 382         final TypeDefinition<?> leafType = leaf.getType();
 383
 384         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 385         assertNotNull(result);
 386         assertTrue(result instanceof GeneratedTransferObject);
 387         assertEquals("YangUnion", result.getName());
 388         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 389     }
 390
 391     @Test
 392     public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
 393         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 394         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 395             "complex-union");
 396         final TypeDefinition<?> leafType = leaf.getType();
 397
 398         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 399         assertNotNull(result);
 400         assertTrue(result instanceof GeneratedTransferObject);
 401         assertEquals("ComplexUnion", result.getName());
 402         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 403     }
 404
 405     @Test
 406     public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
 407         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 408         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 409             "complex-string-int-union");
 410         final TypeDefinition<?> leafType = leaf.getType();
 411
 412         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 413         assertNotNull(result);
 414         assertTrue(result instanceof GeneratedTransferObject);
 415         assertEquals("ComplexStringIntUnion", result.getName());
 416         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 417     }
 418
 419     @Test
 420     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
 421         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 422
 423         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER, "complex-union");
 424
 425         assertNotNull(unionTypeDef);
 426         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 427         GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
 428             JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
 429             (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
 430
 431         assertNotNull(unionTypeBuilder);
 432
 433         GeneratedTransferObject unionType = unionTypeBuilder.build();
 434         assertEquals("ComplexUnion", unionType.getName());
 435     }
 436
 437     @Test
 438     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
 439         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 440
 441         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER,
 442             "complex-string-int-union");
 443
 444         assertNotNull(unionTypeDef);
 445         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 446         final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
 447             JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
 448             (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
 449
 450         assertNotNull(unionTypeBuilder);
 451
 452         final GeneratedTransferObject unionType = unionTypeBuilder.build();
 453         assertEquals("ComplexStringIntUnion", unionType.getName());
 454     }
 455
 456     @Test
 457     public void generatedTypeForExtendedDefinitionTypeTest() {
 458         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 459
 460         final Module baseYangTypes = resolveModule("base-yang-types");
 461
 462         Type yangBoolean = null;
 463         Type yangEmpty = null;
 464         Type yangEnumeration = null;
 465         Type yangInt8 = null;
 466         Type yangInt8Restricted = null;
 467         Type yangInt16 = null;
 468         Type yangInt32 = null;
 469         Type yangInt64 = null;
 470         Type yangString = null;
 471         Type yangDecimal = null;
 472         Type yangUint8 = null;
 473         Type yangUint16 = null;
 474         Type yangUint32 = null;
 475         Type yangUint64 = null;
 476         Type yangUnion = null;
 477         Type yangBinary = null;
 478         Type yangBits = null;
 479         Type yangInstanceIdentifier = null;
 480
 481         for (final TypeDefinition<?> typedef : baseYangTypes.getTypeDefinitions()) {
 482             final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
 483             if (type instanceof GeneratedTransferObject) {
 484                 if (type.getName().equals("YangBoolean")) {
 485                     yangBoolean = type;
 486                 } else if (type.getName().equals("YangEmpty")) {
 487                     yangEmpty = type;
 488                 } else if (type.getName().equals("YangInt8")) {
 489                     yangInt8 = type;
 490                 } else if (type.getName().equals("YangInt8Restricted")) {
 491                     yangInt8Restricted = type;
 492                 } else if (type.getName().equals("YangInt16")) {
 493                     yangInt16 = type;
 494                 } else if (type.getName().equals("YangInt32")) {
 495                     yangInt32 = type;
 496                 } else if (type.getName().equals("YangInt64")) {
 497                     yangInt64 = type;
 498                 } else if (type.getName().equals("YangString")) {
 499                     yangString = type;
 500                 } else if (type.getName().equals("YangDecimal64")) {
 501                     yangDecimal = type;
 502                 } else if (type.getName().equals("YangUint8")) {
 503                     yangUint8 = type;
 504                 } else if (type.getName().equals("YangUint16")) {
 505                     yangUint16 = type;
 506                 } else if (type.getName().equals("YangUint32")) {
 507                     yangUint32 = type;
 508                 } else if (type.getName().equals("YangUint64")) {
 509                     yangUint64 = type;
 510                 } else if (type.getName().equals("YangUnion")) {
 511                     yangUnion = type;
 512                 } else if (type.getName().equals("YangBinary")) {
 513                     yangBinary = type;
 514                 } else if (type.getName().equals("YangInstanceIdentifier")) {
 515                     yangInstanceIdentifier = type;
 516                 } else if (type.getName().equals("YangBits")) {
 517                     yangBits = type;
 518                 }
 519             } else if (type instanceof Enumeration) {
 520                 if (type.getName().equals("YangEnumeration")) {
 521                     yangEnumeration = type;
 522                 }
 523             }
 524         }
 525
 526         assertNotNull(yangBoolean);
 527         assertNotNull(yangEmpty);
 528         assertNotNull(yangEnumeration);
 529         assertNotNull(yangInt8);
 530         assertNotNull(yangInt8Restricted);
 531         assertNotNull(yangInt16);
 532         assertNotNull(yangInt32);
 533         assertNotNull(yangInt64);
 534         assertNotNull(yangString);
 535         assertNotNull(yangDecimal);
 536         assertNotNull(yangUint8);
 537         assertNotNull(yangUint16);
 538         assertNotNull(yangUint32);
 539         assertNotNull(yangUint64);
 540         assertNotNull(yangUnion);
 541         assertNotNull(yangBinary);
 542         assertNotNull(yangBits);
 543         assertNotNull(yangInstanceIdentifier);
 544     }
 545
 546     @Test(expected = IllegalArgumentException.class)
 547     public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
 548         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 549         provider.generatedTypeForExtendedDefinitionType(null, null);
 550     }
 551
 552     @Test(expected = IllegalArgumentException.class)
 553     public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
 554         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 555         final TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
 556         provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
 557     }
 558
 559     @Test
 560     public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
 561         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 562
 563         final Module baseYangTypes = resolveModule("test-type-provider");
 564         final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes,
 565             "extended-yang-int8");
 566         assertNotNull(extYangInt8Typedef);
 567         final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
 568         assertNotNull(extType);
 569         assertTrue(extType instanceof GeneratedTransferObject);
 570     }
 571
 572     @Test
 573     public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
 574         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 575
 576         final Module baseYangTypes = resolveModule("test-type-provider");
 577         final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes,
 578             "bar-item-leafref-id");
 579         assertNotNull(barItemLeafrefId);
 580         final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
 581         assertEquals(null, extType);
 582     }
 583
 584     @Test
 585     public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
 586         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 587
 588         final Module baseYangTypes = resolveModule("test-type-provider");
 589
 590         final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes,
 591             "aes-identityref-type");
 592
 593         assertNotNull(aesIdentityrefType);
 594         final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
 595         assertEquals(null, extType);
 596     }
 597
 598     @Test(expected = NullPointerException.class)
 599     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
 600         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 601         provider.provideGeneratedTOBuilderForBitsTypeDefinition(JavaTypeName.create("foo", "foo"), null, "foo");
 602     }
 603
 604     @Test
 605     public void addUnitsToGenTOTest() {
 606         final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(
 607             JavaTypeName.create("test.package", "TestBuilder"));
 608
 609         CodegenTypeProvider.addUnitsToGenTO(builder, null);
 610         GeneratedTransferObject genTO = builder.build();
 611         assertTrue(genTO.getConstantDefinitions().isEmpty());
 612
 613         CodegenTypeProvider.addUnitsToGenTO(builder, "");
 614         genTO = builder.build();
 615         assertTrue(genTO.getConstantDefinitions().isEmpty());
 616
 617         CodegenTypeProvider.addUnitsToGenTO(builder, "125");
 618         genTO = builder.build();
 619         assertTrue(!genTO.getConstantDefinitions().isEmpty());
 620         assertEquals(1, genTO.getConstantDefinitions().size());
 621         assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
 622         assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
 623     }
 624 }