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.model.ri.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     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 TypeProvider 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 TypeProvider 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     // FIXME: Remove @Ignore annotation once the bug https://bugs.opendaylight.org/show_bug.cgi?id=1862 is fixed
 186     @Ignore
 187     @Test
 188     public void bug1862RestrictedTypedefTransformationTest() {
 189         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 190         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 191             "bug-1862-restricted-typedef");
 192
 193         final TypeDefinition<?> leafType = leaf.getType();
 194         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 195         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 196         assertNotNull(result);
 197         assertTrue(result instanceof GeneratedTransferObject);
 198         //TODO: complete test after bug 1862 is fixed
 199     }
 200
 201     @Test
 202     public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
 203         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 204         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-enum-leaf");
 205         TypeDefinition<?> leafType = leaf.getType();
 206         Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 207         assertNotNull(result);
 208         assertTrue(result instanceof Enumeration);
 209
 210         final Enumeration enumType = (Enumeration) result;
 211         final List<Enumeration.Pair> enumValues = enumType.getValues();
 212         assertTrue(!enumValues.isEmpty());
 213         assertEquals("a", enumValues.get(0).getName());
 214         assertEquals("b", enumValues.get(1).getName());
 215         assertEquals("A", enumValues.get(0).getMappedName());
 216         assertEquals("B", enumValues.get(1).getMappedName());
 217
 218         leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-direct-use-of-enum");
 219         leafType = leaf.getType();
 220         result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 221         assertNotNull(result);
 222         assertTrue(result instanceof ConcreteType);
 223
 224         assertEquals("java.lang", result.getPackageName());
 225         assertEquals("Enum", result.getName());
 226     }
 227
 228     @Test
 229     public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
 230         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 231         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar", "leafref-value");
 232         TypeDefinition<?> leafType = leaf.getType();
 233         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 234         assertNotNull(leafrefResolvedType1);
 235         assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
 236
 237         final Module module = resolveModule("test-type-provider-b");
 238         final QName leafNode = QName.create(module.getQNameModule(), "id");
 239         final DataSchemaNode rootNode = module.findDataChildByName(leafNode).get();
 240         assertNotNull("leaf id is not present in root of module " + module.getName(), rootNode);
 241         assertTrue(rootNode instanceof LeafSchemaNode);
 242         leaf = (LeafSchemaNode) rootNode;
 243         leafType = leaf.getType();
 244
 245         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 246         assertNotNull(leafrefResolvedType2);
 247         assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
 248     }
 249
 250     @Test
 251     public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
 252         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 253
 254         setReferencedTypeForTypeProvider(provider);
 255
 256         final Module module = resolveModule("test-type-provider-b");
 257
 258         final QName leafNode = QName.create(module.getQNameModule(), "enum");
 259         final DataSchemaNode enumNode = module.findDataChildByName(leafNode).get();
 260         assertTrue(enumNode instanceof LeafSchemaNode);
 261         final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
 262         final TypeDefinition<?> leafType = leaf.getType();
 263
 264         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 265         assertNotNull(leafrefResolvedType1);
 266
 267         final QName leafListNode = QName.create(module.getQNameModule(), "enums");
 268         final DataSchemaNode enumListNode = module.findDataChildByName(leafListNode).get();
 269         assertTrue(enumListNode instanceof LeafListSchemaNode);
 270         final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
 271         final TypeDefinition<?> leafListType = leafList.getType();
 272
 273         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
 274         assertNotNull(leafrefResolvedType2);
 275         assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
 276     }
 277
 278     private static void setReferencedTypeForTypeProvider(final AbstractTypeProvider provider) {
 279         final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 280             "resolve-direct-use-of-enum");
 281         final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
 282         provider.putReferencedType(enumLeafNode.getPath(),
 283             Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode)));
 284
 285         final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(TEST_TYPE_PROVIDER,
 286             "foo", "list-of-enums");
 287         final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
 288         provider.putReferencedType(enumListNode.getPath(),
 289             Type.of(provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode)));
 290     }
 291
 292     @Test
 293     public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
 294         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 295         final Module module = resolveModule("test-type-provider-b");
 296
 297         final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
 298         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 299         assertTrue(condLeaf instanceof LeafSchemaNode);
 300         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 301         final TypeDefinition<?> leafType = leaf.getType();
 302
 303         final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 304         assertNotNull(resultType);
 305         assertTrue(resultType instanceof ConcreteType);
 306         assertEquals("java.lang", resultType.getPackageName());
 307         assertEquals("Object", resultType.getName());
 308     }
 309
 310     @Test(expected = IllegalArgumentException.class)
 311     public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
 312         final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 313         final Module module = resolveModule("test-type-provider-b");
 314
 315         final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
 316         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 317         assertTrue(condLeaf instanceof LeafSchemaNode);
 318         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 319         final TypeDefinition<?> leafType = leaf.getType();
 320
 321         provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 322     }
 323
 324     @Test
 325     public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
 326         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 327         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "crypto");
 328         final TypeDefinition<?> leafType = leaf.getType();
 329
 330         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 331         assertNotNull(result);
 332         assertTrue(result instanceof ParameterizedType);
 333     }
 334
 335     @Test
 336     public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
 337         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 338         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 339             "simple-int-types-union");
 340         final TypeDefinition<?> leafType = leaf.getType();
 341
 342         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 343         assertNotNull(result);
 344         assertTrue(result instanceof GeneratedTransferObject);
 345         assertEquals("YangUnion", result.getName());
 346         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 347     }
 348
 349     @Test
 350     public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
 351         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 352         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 353             "complex-union");
 354         final TypeDefinition<?> leafType = leaf.getType();
 355
 356         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 357         assertNotNull(result);
 358         assertTrue(result instanceof GeneratedTransferObject);
 359         assertEquals("ComplexUnion", result.getName());
 360         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 361     }
 362
 363     @Test
 364     public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
 365         final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 366         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
 367             "complex-string-int-union");
 368         final TypeDefinition<?> leafType = leaf.getType();
 369
 370         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 371         assertNotNull(result);
 372         assertTrue(result instanceof GeneratedTransferObject);
 373         assertEquals("ComplexStringIntUnion", result.getName());
 374         //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
 375     }
 376
 377     @Test
 378     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
 379         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 380
 381         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER, "complex-union");
 382
 383         assertNotNull(unionTypeDef);
 384         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 385         GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
 386             JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
 387             (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
 388
 389         assertNotNull(unionTypeBuilder);
 390
 391         GeneratedTransferObject unionType = unionTypeBuilder.build();
 392         assertEquals("ComplexUnion", unionType.getName());
 393     }
 394
 395     @Test
 396     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
 397         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 398
 399         final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER,
 400             "complex-string-int-union");
 401
 402         assertNotNull(unionTypeDef);
 403         assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
 404         final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
 405             JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
 406             (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
 407
 408         assertNotNull(unionTypeBuilder);
 409
 410         final GeneratedTransferObject unionType = unionTypeBuilder.build();
 411         assertEquals("ComplexStringIntUnion", unionType.getName());
 412     }
 413
 414     @Test
 415     public void generatedTypeForExtendedDefinitionTypeTest() {
 416         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 417
 418         final Module baseYangTypes = resolveModule("base-yang-types");
 419
 420         Type yangBoolean = null;
 421         Type yangEmpty = null;
 422         Type yangEnumeration = null;
 423         Type yangInt8 = null;
 424         Type yangInt8Restricted = null;
 425         Type yangInt16 = null;
 426         Type yangInt32 = null;
 427         Type yangInt64 = null;
 428         Type yangString = null;
 429         Type yangDecimal = null;
 430         Type yangUint8 = null;
 431         Type yangUint16 = null;
 432         Type yangUint32 = null;
 433         Type yangUint64 = null;
 434         Type yangUnion = null;
 435         Type yangBinary = null;
 436         Type yangBits = null;
 437         Type yangInstanceIdentifier = null;
 438
 439         for (final TypeDefinition<?> typedef : baseYangTypes.getTypeDefinitions()) {
 440             final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
 441             if (type instanceof GeneratedTransferObject) {
 442                 if (type.getName().equals("YangBoolean")) {
 443                     yangBoolean = type;
 444                 } else if (type.getName().equals("YangEmpty")) {
 445                     yangEmpty = type;
 446                 } else if (type.getName().equals("YangInt8")) {
 447                     yangInt8 = type;
 448                 } else if (type.getName().equals("YangInt8Restricted")) {
 449                     yangInt8Restricted = type;
 450                 } else if (type.getName().equals("YangInt16")) {
 451                     yangInt16 = type;
 452                 } else if (type.getName().equals("YangInt32")) {
 453                     yangInt32 = type;
 454                 } else if (type.getName().equals("YangInt64")) {
 455                     yangInt64 = type;
 456                 } else if (type.getName().equals("YangString")) {
 457                     yangString = type;
 458                 } else if (type.getName().equals("YangDecimal64")) {
 459                     yangDecimal = type;
 460                 } else if (type.getName().equals("YangUint8")) {
 461                     yangUint8 = type;
 462                 } else if (type.getName().equals("YangUint16")) {
 463                     yangUint16 = type;
 464                 } else if (type.getName().equals("YangUint32")) {
 465                     yangUint32 = type;
 466                 } else if (type.getName().equals("YangUint64")) {
 467                     yangUint64 = type;
 468                 } else if (type.getName().equals("YangUnion")) {
 469                     yangUnion = type;
 470                 } else if (type.getName().equals("YangBinary")) {
 471                     yangBinary = type;
 472                 } else if (type.getName().equals("YangInstanceIdentifier")) {
 473                     yangInstanceIdentifier = type;
 474                 } else if (type.getName().equals("YangBits")) {
 475                     yangBits = type;
 476                 }
 477             } else if (type instanceof Enumeration) {
 478                 if (type.getName().equals("YangEnumeration")) {
 479                     yangEnumeration = type;
 480                 }
 481             }
 482         }
 483
 484         assertNotNull(yangBoolean);
 485         assertNotNull(yangEmpty);
 486         assertNotNull(yangEnumeration);
 487         assertNotNull(yangInt8);
 488         assertNotNull(yangInt8Restricted);
 489         assertNotNull(yangInt16);
 490         assertNotNull(yangInt32);
 491         assertNotNull(yangInt64);
 492         assertNotNull(yangString);
 493         assertNotNull(yangDecimal);
 494         assertNotNull(yangUint8);
 495         assertNotNull(yangUint16);
 496         assertNotNull(yangUint32);
 497         assertNotNull(yangUint64);
 498         assertNotNull(yangUnion);
 499         assertNotNull(yangBinary);
 500         assertNotNull(yangBits);
 501         assertNotNull(yangInstanceIdentifier);
 502     }
 503
 504     @Test
 505     public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
 506         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 507
 508         final Module baseYangTypes = resolveModule("test-type-provider");
 509         final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes,
 510             "extended-yang-int8");
 511         assertNotNull(extYangInt8Typedef);
 512         final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
 513         assertNotNull(extType);
 514         assertTrue(extType instanceof GeneratedTransferObject);
 515     }
 516
 517     @Test
 518     public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
 519         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 520
 521         final Module baseYangTypes = resolveModule("test-type-provider");
 522         final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes,
 523             "bar-item-leafref-id");
 524         assertNotNull(barItemLeafrefId);
 525         final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
 526         assertEquals(null, extType);
 527     }
 528
 529     @Test
 530     public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
 531         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 532
 533         final Module baseYangTypes = resolveModule("test-type-provider");
 534
 535         final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes,
 536             "aes-identityref-type");
 537
 538         assertNotNull(aesIdentityrefType);
 539         final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
 540         assertEquals(null, extType);
 541     }
 542
 543     @Test(expected = NullPointerException.class)
 544     public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
 545         final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
 546         provider.provideGeneratedTOBuilderForBitsTypeDefinition(JavaTypeName.create("foo", "foo"), null, "foo");
 547     }
 548
 549     @Test
 550     public void addUnitsToGenTOTest() {
 551         final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(
 552             JavaTypeName.create("test.package", "TestBuilder"));
 553
 554         CodegenTypeProvider.addUnitsToGenTO(builder, null);
 555         GeneratedTransferObject genTO = builder.build();
 556         assertTrue(genTO.getConstantDefinitions().isEmpty());
 557
 558         CodegenTypeProvider.addUnitsToGenTO(builder, "");
 559         genTO = builder.build();
 560         assertTrue(genTO.getConstantDefinitions().isEmpty());
 561
 562         CodegenTypeProvider.addUnitsToGenTO(builder, "125");
 563         genTO = builder.build();
 564         assertTrue(!genTO.getConstantDefinitions().isEmpty());
 565         assertEquals(1, genTO.getConstantDefinitions().size());
 566         assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
 567         assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
 568     }
 569 }