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