2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.yangtools.sal.binding.yang.types;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertTrue;
14 import java.math.BigInteger;
15 import java.util.List;
17 import org.junit.Before;
18 import org.junit.Ignore;
19 import org.junit.Test;
20 import org.junit.runner.RunWith;
21 import org.junit.runners.JUnit4;
22 import org.mockito.Mock;
23 import org.mockito.MockitoAnnotations;
24 import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
25 import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;
26 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
27 import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;
28 import org.opendaylight.yangtools.sal.binding.model.api.*;
29 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
30 import org.opendaylight.yangtools.yang.model.api.*;
31 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
32 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
33 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
36 * Test suite for testing public methods in TypeProviderImpl class
38 * @see org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl
40 * @author Lukas Sedlak <lsedlak@cisco.com>
42 @RunWith(JUnit4.class)
43 public class TypeProviderTest {
45 private SchemaContext schemaContext;
46 private Set<Module> schemaModules;
47 private Module testTypeProviderModule;
50 private SchemaPath schemaPath;
53 private SchemaNode schemaNode;
57 MockitoAnnotations.initMocks(this);
58 schemaContext = TypeProviderModel.createTestContext();
59 assertNotNull(schemaContext);
60 schemaModules = schemaContext.getModules();
61 assertNotNull(schemaModules);
62 testTypeProviderModule = resolveModule(TypeProviderModel.TEST_TYPE_PROVIDER_MODULE_NAME);
63 assertNotNull(testTypeProviderModule);
66 private Module resolveModule(final String moduleName) {
67 assertNotNull(moduleName);
68 for (Module m : schemaModules) {
69 if (moduleName.equals(m.getName())) {
73 assertTrue("Unable to resolve module " + moduleName + ". No module present within Schema Context!" , false);
77 @Test(expected = IllegalArgumentException.class)
78 public void typeProviderInstanceWithNullSchemaContextTest() {
79 final TypeProvider provider = new TypeProviderImpl(null);
82 @Test(expected = IllegalArgumentException.class)
83 public void putReferencedTypeWithNullSchemaPathParamTest() {
84 final TypeProvider provider = new TypeProviderImpl(schemaContext);
86 ((TypeProviderImpl) provider).putReferencedType(null, null);
87 ((TypeProviderImpl) provider).putReferencedType(schemaPath, null);
90 @Test(expected = IllegalArgumentException.class)
91 public void putReferencedTypeWithNullRefTypeParamTest() {
92 final TypeProvider provider = new TypeProviderImpl(schemaContext);
94 ((TypeProviderImpl) provider).putReferencedType(schemaPath, null);
98 public void getAdditionalTypesTest() {
99 final TypeProvider provider = new TypeProviderImpl(schemaContext);
101 assertNotNull(((TypeProviderImpl) provider).getAdditionalTypes());
104 @Test(expected = IllegalArgumentException.class)
105 public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
106 final TypeProvider provider = new TypeProviderImpl(schemaContext);
108 provider.javaTypeForSchemaDefinitionType(null, null, null);
111 @Test(expected = IllegalArgumentException.class)
112 public void javaTypeForSchemaDefinitionTypeTypedefNullQNameTest() {
113 final TypeProvider provider = new TypeProviderImpl(schemaContext);
115 TestIntegerTypeDefinition testTypedef = new TestIntegerTypeDefinition();
116 provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
119 private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName, final String leafNodeName) {
120 final DataSchemaNode rootNode = module.getDataChildByName(containerName);
121 assertNotNull("Container foo is not present in root of module "+ module.getName(), rootNode);
122 assertTrue(rootNode instanceof DataNodeContainer);
124 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
125 final DataSchemaNode node = rootContainer.getDataChildByName(leafNodeName);
127 assertTrue(node instanceof LeafSchemaNode);
128 return (LeafSchemaNode) node;
131 private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module, final String containerName, final String leafListNodeName) {
132 final DataSchemaNode rootNode = module.getDataChildByName(containerName);
133 assertNotNull("Container foo is not present in root of module "+ module.getName(), rootNode);
134 assertTrue(rootNode instanceof DataNodeContainer);
136 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
137 final DataSchemaNode node = rootContainer.getDataChildByName(leafListNodeName);
139 assertTrue(node instanceof LeafListSchemaNode);
140 return (LeafListSchemaNode) node;
144 public void javaTypeForSchemaDefinitionExtTypeTest() {
145 final TypeProvider provider = new TypeProviderImpl(schemaContext);
146 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
148 final TypeDefinition<?> leafType = leaf.getType();
149 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
150 assertNotNull(result);
151 assertTrue(result instanceof GeneratedTransferObject);
153 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
154 assertEquals("base-yang-types", genTO.getModuleName());
155 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
156 assertEquals("YangInt8", genTO.getName());
157 assertTrue(genTO.getProperties().size() == 1);
161 public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
162 final TypeProvider provider = new TypeProviderImpl(schemaContext);
163 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "restricted-int8-type");
165 final TypeDefinition<?> leafType = leaf.getType();
166 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
168 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
169 assertNotNull(result);
170 assertTrue(result instanceof GeneratedTransferObject);
172 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
173 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
174 assertEquals("YangInt8Restricted", genTO.getName());
175 assertTrue(genTO.getProperties().size() == 1);
176 final List<RangeConstraint> rangeConstraints = genTO.getRestrictions().getRangeConstraints();
178 assertTrue(!rangeConstraints.isEmpty());
179 final RangeConstraint constraint = rangeConstraints.get(0);
180 assertEquals(BigInteger.ONE, constraint.getMin());
181 assertEquals(BigInteger.valueOf(100), constraint.getMax());
185 public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
186 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
188 final Module testTypeProvider = resolveModule("test-type-provider");
189 final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider, "empty-pattern-string");
191 assertNotNull(emptyPatternString);
192 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
194 Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
195 assertNotNull(result);
196 assertTrue(result instanceof GeneratedTransferObject);
198 result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
199 assertNotNull(result);
200 assertTrue(result instanceof GeneratedTransferObject);
203 private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
204 TypeDefinition<?> result = null;
205 final Set<TypeDefinition<?>> typeDefs = module.getTypeDefinitions();
206 for (final TypeDefinition<?> typedef : typeDefs) {
207 if (typedef.getQName().getLocalName().equals(typedefName)) {
215 * FIXME: Remove @Ignore annotation once the bug https://bugs.opendaylight.org/show_bug.cgi?id=1862 is fixed
219 public void bug1862RestrictedTypedefTransformationTest() {
220 final TypeProvider provider = new TypeProviderImpl(schemaContext);
221 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "bug-1862-restricted-typedef");
223 final TypeDefinition<?> leafType = leaf.getType();
224 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
225 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
226 assertNotNull(result);
227 assertTrue(result instanceof GeneratedTransferObject);
228 //TODO: complete test after bug 1862 is fixed
232 public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
233 final TypeProvider provider = new TypeProviderImpl(schemaContext);
234 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "resolve-enum-leaf");
235 TypeDefinition<?> leafType = leaf.getType();
236 Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
237 assertNotNull(result);
238 assertTrue(result instanceof Enumeration);
240 final Enumeration enumType = (Enumeration) result;
241 final List<Enumeration.Pair> enumValues = enumType.getValues();
242 assertTrue(!enumValues.isEmpty());
243 assertEquals("A", enumValues.get(0).getName());
244 assertEquals("B", enumValues.get(1).getName());
246 leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "resolve-direct-use-of-enum");
247 leafType = leaf.getType();
248 result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
249 assertNotNull(result);
250 assertTrue(result instanceof ConcreteType);
252 assertEquals("java.lang", result.getPackageName());
253 assertEquals("Enum", result.getName());
257 public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
258 final TypeProvider provider = new TypeProviderImpl(schemaContext);
259 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "bar", "leafref-value");
260 TypeDefinition<?> leafType = leaf.getType();
261 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
262 assertNotNull(leafrefResolvedType1);
263 assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
265 final Module module = resolveModule("test-type-provider-b");
266 final DataSchemaNode rootNode = module.getDataChildByName("id");
267 assertNotNull("leaf id is not present in root of module "+ module.getName(), rootNode);
268 assertTrue(rootNode instanceof LeafSchemaNode);
269 leaf = (LeafSchemaNode) rootNode;
270 leafType = leaf.getType();
272 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
273 assertNotNull(leafrefResolvedType2);
274 assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
278 public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
279 final TypeProvider provider = new TypeProviderImpl(schemaContext);
281 setReferencedTypeForTypeProvider(provider);
283 final Module module = resolveModule("test-type-provider-b");
285 final DataSchemaNode enumNode = module.getDataChildByName("enum");
286 assertNotNull("leaf enum is not present in root of module " + module.getName(), enumNode);
287 assertTrue(enumNode instanceof LeafSchemaNode);
288 LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
289 final TypeDefinition<?> leafType = leaf.getType();
291 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
292 assertNotNull(leafrefResolvedType1);
293 assertTrue(leafrefResolvedType1 instanceof ReferencedTypeImpl);
295 final DataSchemaNode enumListNode = module.getDataChildByName("enums");
296 assertNotNull("leaf-list enums is not present in root of module "+ module.getName(), enumNode);
297 assertTrue(enumListNode instanceof LeafListSchemaNode);
298 LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
299 TypeDefinition<?> leafListType = leafList.getType();
301 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
302 assertNotNull(leafrefResolvedType2);
303 assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
306 private void setReferencedTypeForTypeProvider(TypeProvider provider) {
307 final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo",
308 "resolve-direct-use-of-enum");
309 final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
310 Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
312 Type refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getName());
313 ((TypeProviderImpl) provider).putReferencedType(enumLeafNode.getPath(), refType);
315 final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(testTypeProviderModule, "foo",
317 final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
318 enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
320 refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getPackageName());
321 ((TypeProviderImpl) provider).putReferencedType(enumListNode.getPath(), refType);
325 public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
326 final TypeProvider provider = new TypeProviderImpl(schemaContext);
327 final Module module = resolveModule("test-type-provider-b");
329 final DataSchemaNode condLeaf = module.getDataChildByName("conditional-leafref");
330 assertNotNull("leaf conditional-leafref is not present in root of module "+ module.getName(), condLeaf);
331 assertTrue(condLeaf instanceof LeafSchemaNode);
332 LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
333 final TypeDefinition<?> leafType = leaf.getType();
335 final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
336 assertNotNull(resultType);
337 assertTrue(resultType instanceof ConcreteType);
338 assertEquals("java.lang", resultType.getPackageName());
339 assertEquals("Object", resultType.getName());
342 @Test(expected = IllegalArgumentException.class)
343 public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
344 final TypeProvider provider = new TypeProviderImpl(schemaContext);
345 final Module module = resolveModule("test-type-provider-b");
347 final DataSchemaNode condLeaf = module.getDataChildByName("unreslovable-leafref");
348 assertNotNull("leaf unreslovable-leafref is not present in root of module "+ module.getName(), condLeaf);
349 assertTrue(condLeaf instanceof LeafSchemaNode);
350 LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
351 final TypeDefinition<?> leafType = leaf.getType();
353 provider.javaTypeForSchemaDefinitionType(leafType, leaf);
356 @Test(expected = IllegalArgumentException.class)
357 public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
358 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
360 provider.provideTypeForLeafref(null, null);
363 @Test(expected = IllegalArgumentException.class)
364 public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
365 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
367 final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
368 provider.provideTypeForLeafref(leafrePath, schemaNode);
371 @Test(expected = IllegalArgumentException.class)
372 public void provideTypeForLeafrefWithNullRewisionAwareXPathTest() {
373 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
375 final LeafrefTypeWithNullToStringInXpath leafrePath = new LeafrefTypeWithNullToStringInXpath();
376 provider.provideTypeForLeafref(leafrePath, schemaNode);
379 @Test(expected = IllegalStateException.class)
380 public void provideTypeForLeafrefWithNullParentModuleTest() {
381 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
382 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "bar", "leafref-value");
383 TypeDefinition<?> leafType = leaf.getType();
384 assertTrue(leafType instanceof LeafrefTypeDefinition);
385 provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, schemaNode);
389 public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
390 final TypeProvider provider = new TypeProviderImpl(schemaContext);
391 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "crypto");
392 final TypeDefinition<?> leafType = leaf.getType();
394 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
395 assertNotNull(result);
396 assertTrue(result instanceof ParameterizedType);
400 public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
401 final TypeProvider provider = new TypeProviderImpl(schemaContext);
402 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "use-of-unions", "simple-int-types-union");
403 final TypeDefinition<?> leafType = leaf.getType();
405 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
406 assertNotNull(result);
407 assertTrue(result instanceof GeneratedTransferObject);
408 assertEquals("YangUnion", result.getName());
409 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
413 public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
414 final TypeProvider provider = new TypeProviderImpl(schemaContext);
415 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "use-of-unions", "complex-union");
416 final TypeDefinition<?> leafType = leaf.getType();
418 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
419 assertNotNull(result);
420 assertTrue(result instanceof GeneratedTransferObject);
421 assertEquals("ComplexUnion", result.getName());
422 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
426 public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
427 final TypeProvider provider = new TypeProviderImpl(schemaContext);
428 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "use-of-unions", "complex-string-int-union");
429 final TypeDefinition<?> leafType = leaf.getType();
431 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
432 assertNotNull(result);
433 assertTrue(result instanceof GeneratedTransferObject);
434 assertEquals("ComplexStringIntUnion", result.getName());
435 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
439 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
440 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
442 final Module testTypeProvider = resolveModule("test-type-provider");
443 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-union");
445 assertNotNull(unionTypeDef);
446 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
447 GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
448 (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexUnionType", unionTypeDef);
450 assertNotNull(unionTypeBuilder);
452 GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
453 assertEquals("ComplexUnionType", unionType.getName());
455 unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
456 (UnionTypeDefinition)unionTypeDef.getBaseType(), "", unionTypeDef);
458 assertNotNull(unionTypeBuilder);
460 unionType = unionTypeBuilder.toInstance();
461 assertEquals("Union", unionType.getName());
463 unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
464 (UnionTypeDefinition)unionTypeDef.getBaseType(), null, unionTypeDef);
466 assertNotNull(unionTypeBuilder);
468 unionType = unionTypeBuilder.toInstance();
469 assertEquals("Union", unionType.getName());
473 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
474 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
476 final Module testTypeProvider = resolveModule("test-type-provider");
477 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-string-int-union");
479 assertNotNull(unionTypeDef);
480 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
481 final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
482 (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexStringIntUnionType", unionTypeDef);
484 assertNotNull(unionTypeBuilder);
486 GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
487 assertEquals("ComplexStringIntUnionType", unionType.getName());
491 public void generatedTypeForExtendedDefinitionTypeTest() {
492 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
494 final Module baseYangTypes = resolveModule("base-yang-types");
495 final Set<TypeDefinition<?>> typeDefs = baseYangTypes.getTypeDefinitions();
497 Type yangBoolean = null;
498 Type yangEmpty = null;
499 Type yangEnumeration = null;
500 Type yangInt8 = null;
501 Type yangInt8Restricted = null;
502 Type yangInt16 = null;
503 Type yangInt32 = null;
504 Type yangInt64 = null;
505 Type yangString = null;
506 Type yangDecimal = null;
507 Type yangUint8 = null;
508 Type yangUint16 = null;
509 Type yangUint32 = null;
510 Type yangUint64 = null;
511 Type yangUnion = null;
512 Type yangBinary = null;
513 Type yangBits = null;
514 Type yangInstanceIdentifier = null;
516 for (TypeDefinition<?> typedef : typeDefs) {
517 Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
518 if (type instanceof GeneratedTransferObject) {
519 if (type.getName().equals("YangBoolean")) {
521 } else if (type.getName().equals("YangEmpty")) {
523 } else if (type.getName().equals("YangInt8")) {
525 } else if (type.getName().equals("YangInt8Restricted")) {
526 yangInt8Restricted = type;
527 } else if (type.getName().equals("YangInt16")) {
529 } else if (type.getName().equals("YangInt32")) {
531 } else if (type.getName().equals("YangInt64")) {
533 } else if (type.getName().equals("YangString")) {
535 } else if (type.getName().equals("YangDecimal64")) {
537 } else if (type.getName().equals("YangUint8")) {
539 } else if (type.getName().equals("YangUint16")) {
541 } else if (type.getName().equals("YangUint32")) {
543 } else if (type.getName().equals("YangUint64")) {
545 } else if (type.getName().equals("YangUnion")) {
547 } else if (type.getName().equals("YangBinary")) {
549 } else if (type.getName().equals("YangInstanceIdentifier")) {
550 yangInstanceIdentifier = type;
551 } else if (type.getName().equals("YangBits")) {
554 } else if (type instanceof Enumeration) {
555 if (type.getName().equals("YangEnumeration")) {
556 yangEnumeration = type;
561 assertNotNull(yangBoolean);
562 assertNotNull(yangEmpty);
563 assertNotNull(yangEnumeration);
564 assertNotNull(yangInt8);
565 assertNotNull(yangInt8Restricted);
566 assertNotNull(yangInt16);
567 assertNotNull(yangInt32);
568 assertNotNull(yangInt64);
569 assertNotNull(yangString);
570 assertNotNull(yangDecimal);
571 assertNotNull(yangUint8);
572 assertNotNull(yangUint16);
573 assertNotNull(yangUint32);
574 assertNotNull(yangUint64);
575 assertNotNull(yangUnion);
576 assertNotNull(yangBinary);
577 assertNotNull(yangBits);
578 assertNotNull(yangInstanceIdentifier);
581 @Test(expected = IllegalArgumentException.class)
582 public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
583 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
584 provider.generatedTypeForExtendedDefinitionType(null, null);
587 @Test(expected = IllegalArgumentException.class)
588 public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
589 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
590 TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
591 provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
595 public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
596 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
598 final Module baseYangTypes = resolveModule("test-type-provider");
599 TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes, "extended-yang-int8");
600 assertNotNull(extYangInt8Typedef);
601 Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
602 assertNotNull(extType);
603 assertTrue(extType instanceof GeneratedTransferObject);
607 public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
608 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
610 final Module baseYangTypes = resolveModule("test-type-provider");
611 TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes, "bar-item-leafref-id");
612 assertNotNull(barItemLeafrefId);
613 Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
614 assertEquals(null, extType);
618 public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
619 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
621 final Module baseYangTypes = resolveModule("test-type-provider");
623 TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes, "aes-identityref-type");
625 assertNotNull(aesIdentityrefType);
626 Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
627 assertEquals(null, extType);
630 @Test(expected = IllegalArgumentException.class)
631 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
632 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
633 provider.provideGeneratedTOBuilderForBitsTypeDefinition("", null, "", "");
636 @Test(expected = IllegalArgumentException.class)
637 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithBasePackageNullTest() {
638 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
639 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
640 final TypeDefinition<?> leafType = leaf.getType();
641 provider.provideGeneratedTOBuilderForBitsTypeDefinition(null, leafType, "", "");
645 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNonBitsTypedefTest() {
646 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
648 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
649 final TypeDefinition<?> leafType = leaf.getType();
650 Type type = provider.provideGeneratedTOBuilderForBitsTypeDefinition("", leafType, "", "");
652 assertEquals(null, type);
656 public void getConstructorPropertyNameTest() {
657 final TypeProvider provider = new TypeProviderImpl(schemaContext);
659 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
660 final TypeDefinition<?> leafType = leaf.getType();
662 final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
663 assertEquals("value", ctorPropertyName);
665 final String emptyStringName = provider.getConstructorPropertyName(leaf);
666 assertTrue(emptyStringName.isEmpty());
670 public void getParamNameFromTypeTest() {
671 final TypeProvider provider = new TypeProviderImpl(schemaContext);
673 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
674 final TypeDefinition<?> leafType = leaf.getType();
676 final String paramName = provider.getParamNameFromType(leafType);
677 assertEquals("yangInt8", paramName);
681 public void addUnitsToGenTOTest() {
682 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
684 GeneratedTOBuilder builder = new GeneratedTOBuilderImpl("test.package", "TestBuilder");
686 provider.addUnitsToGenTO(builder, null);
687 GeneratedTransferObject genTO = builder.toInstance();
688 assertTrue(genTO.getConstantDefinitions().isEmpty());
690 provider.addUnitsToGenTO(builder, "");
691 genTO = builder.toInstance();
692 assertTrue(genTO.getConstantDefinitions().isEmpty());
694 provider.addUnitsToGenTO(builder, "125");
695 genTO = builder.toInstance();
696 assertTrue(!genTO.getConstantDefinitions().isEmpty());
697 assertEquals(1, genTO.getConstantDefinitions().size());
698 assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
699 assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
702 @Test(expected = NullPointerException.class)
703 public void getTypeDefaultConstructionLeafTypeNullTest() {
704 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
705 TestLeafSchemaNode leafSchemaNode = new TestLeafSchemaNode();
706 provider.getTypeDefaultConstruction(leafSchemaNode, null);
709 @Test(expected = NullPointerException.class)
710 public void getTypeDefaultConstructionDefaultValueNullTest() {
711 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
712 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
713 provider.getTypeDefaultConstruction(leaf, null);
716 private LeafSchemaNode provideLeafForGetDefaultConstructionTestCase(final String leafName) {
717 return provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "construction-type-test",
721 @Test(expected = UnsupportedOperationException.class)
722 public void getTypeDefaultConstructionDefaultValueForInstanceIdentifierTest() {
723 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
724 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("foo-container-id");
725 provider.getTypeDefaultConstruction(leaf, "NAN");
728 @Test(expected = UnsupportedOperationException.class)
729 public void getTypeDefaultConstructionDefaultValueForIdentityrefTest() {
730 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
731 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("aes-identityref-type");
732 provider.getTypeDefaultConstruction(leaf, "NAN");
736 public void getTypeDefaultConstructionDefaultValueTest() {
737 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
739 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
740 String result = provider.getTypeDefaultConstruction(leaf, "true");
741 assertNotNull(result);
742 assertTrue(!result.isEmpty());
743 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBoolean(new java.lang.Boolean(\"true\"))",
746 leaf = provideLeafForGetDefaultConstructionTestCase("yang-empty");
747 result = provider.getTypeDefaultConstruction(leaf, "true");
748 assertNotNull(result);
749 assertTrue(!result.isEmpty());
750 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEmpty(new java.lang.Boolean(\"true\"))",
753 leaf = provideLeafForGetDefaultConstructionTestCase("yang-enumeration");
754 result = provider.getTypeDefaultConstruction(leaf, "a");
755 assertNotNull(result);
756 assertTrue(!result.isEmpty());
757 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEnumeration.A",
760 leaf = provideLeafForGetDefaultConstructionTestCase("direct-use-of-enum");
761 result = provider.getTypeDefaultConstruction(leaf, "y");
762 assertNotNull(result);
763 assertTrue(!result.isEmpty());
764 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.construction.type.test.DirectUseOfEnum.Y",
767 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8");
768 result = provider.getTypeDefaultConstruction(leaf, "17");
769 assertNotNull(result);
770 assertTrue(!result.isEmpty());
771 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(new java.lang.Byte(\"17\"))",
774 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8-restricted");
775 result = provider.getTypeDefaultConstruction(leaf, "99");
776 assertNotNull(result);
777 assertTrue(!result.isEmpty());
778 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8Restricted(new java.lang.Byte(\"99\"))",
781 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int16");
782 result = provider.getTypeDefaultConstruction(leaf, "1024");
783 assertNotNull(result);
784 assertTrue(!result.isEmpty());
785 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(new java.lang.Short(\"1024\"))",
788 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int32");
789 result = provider.getTypeDefaultConstruction(leaf, "1048576");
790 assertNotNull(result);
791 assertTrue(!result.isEmpty());
792 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt32(new java.lang.Integer(\"1048576\"))",
795 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int64");
796 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
797 assertNotNull(result);
798 assertTrue(!result.isEmpty());
799 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt64(new java.lang.Long(\"1099511627776\"))",
802 leaf = provideLeafForGetDefaultConstructionTestCase("yang-string");
803 result = provider.getTypeDefaultConstruction(leaf, "TEST");
804 assertNotNull(result);
805 assertTrue(!result.isEmpty());
806 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangString(\"TEST\")",
809 leaf = provideLeafForGetDefaultConstructionTestCase("yang-decimal64");
810 result = provider.getTypeDefaultConstruction(leaf, "1274.25");
811 assertNotNull(result);
812 assertTrue(!result.isEmpty());
813 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangDecimal64(new java.math.BigDecimal(\"1274.25\"))",
816 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint8");
817 result = provider.getTypeDefaultConstruction(leaf, "128");
818 assertNotNull(result);
819 assertTrue(!result.isEmpty());
820 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint8(new java.lang.Short(\"128\"))",
823 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint16");
824 result = provider.getTypeDefaultConstruction(leaf, "1048576");
825 assertNotNull(result);
826 assertTrue(!result.isEmpty());
827 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint16(new java.lang.Integer(\"1048576\"))",
830 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint32");
831 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
832 assertNotNull(result);
833 assertTrue(!result.isEmpty());
834 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint32(new java.lang.Long(\"1099511627776\"))",
837 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint64");
838 result = provider.getTypeDefaultConstruction(leaf, "1208925819614629174706176");
839 assertNotNull(result);
840 assertTrue(!result.isEmpty());
841 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint64(new java.math.BigInteger(\"1208925819614629174706176\"))",
844 //FIXME: Is this correct scenario and correct result?
845 leaf = provideLeafForGetDefaultConstructionTestCase("complex-union");
846 result = provider.getTypeDefaultConstruction(leaf, "75");
847 assertNotNull(result);
848 assertTrue(!result.isEmpty());
849 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexUnion(\"null\".toCharArray())",
852 //FIXME: Is this correct scenario and correct result?
853 leaf = provideLeafForGetDefaultConstructionTestCase("complex-string-int-union");
854 result = provider.getTypeDefaultConstruction(leaf, "TEST_UNION_STRING_DEFAULT");
855 assertNotNull(result);
856 assertTrue(!result.isEmpty());
857 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexStringIntUnion(\"null\".toCharArray())",
860 leaf = provideLeafForGetDefaultConstructionTestCase("simple-int-types-union");
861 result = provider.getTypeDefaultConstruction(leaf, "2048");
862 assertNotNull(result);
863 assertTrue(!result.isEmpty());
864 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUnion(\"null\".toCharArray())",
868 leaf = provideLeafForGetDefaultConstructionTestCase("direct-union-leaf");
869 result = provider.getTypeDefaultConstruction(leaf);
870 assertNotNull(result);
871 assertTrue(!result.isEmpty());
872 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.DirectUnionLeaf(\"128\".toCharArray())",
875 final Module module = resolveModule("test-type-provider");
876 DataSchemaNode rootNode = module.getDataChildByName("root-union-leaf");
877 assertNotNull("leaf root-union-leaf is not present in root of module "+ module.getName(), rootNode);
878 assertTrue(rootNode instanceof LeafSchemaNode);
879 leaf = (LeafSchemaNode) rootNode;
880 result = provider.getTypeDefaultConstruction(leaf);
881 assertNotNull(result);
882 assertTrue(!result.isEmpty());
883 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootUnionLeaf(\"256\".toCharArray())",
886 leaf = provideLeafForGetDefaultConstructionTestCase("yang-binary");
887 result = provider.getTypeDefaultConstruction(leaf, "0xffffff");
888 assertNotNull(result);
889 assertTrue(!result.isEmpty());
890 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBinary(new byte[] {-45, 23, -33, 125, -9, -33})",
893 rootNode = module.getDataChildByName("root-bits-leaf");
894 assertNotNull("leaf bits-leaf is not present in root of module "+ module.getName(), rootNode);
895 assertTrue(rootNode instanceof LeafSchemaNode);
896 leaf = (LeafSchemaNode) rootNode;
897 result = provider.getTypeDefaultConstruction(leaf);
898 assertNotNull(result);
899 assertTrue(!result.isEmpty());
900 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootBitsLeaf(false, true, false)",
903 leaf = provideLeafForGetDefaultConstructionTestCase("yang-bits");
904 result = provider.getTypeDefaultConstruction(leaf, "10-Mb-only");
905 assertNotNull(result);
906 assertTrue(!result.isEmpty());
907 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBits(true, false, false)",
910 leaf = provideLeafForGetDefaultConstructionTestCase("bar-id");
911 result = provider.getTypeDefaultConstruction(leaf, "128");
912 assertNotNull(result);
913 assertTrue(!result.isEmpty());
914 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(new java.lang.Short(\"128\"))",
917 leaf = provideLeafForGetDefaultConstructionTestCase("foo-leafref-value");
918 result = provider.getTypeDefaultConstruction(leaf, "32");
919 assertNotNull(result);
920 assertTrue(!result.isEmpty());
921 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(new java.lang.Byte(\"32\"))",
924 leaf = provideLeafForGetDefaultConstructionTestCase("foo-cond-bar-item");
925 result = provider.getTypeDefaultConstruction(leaf, "10");
926 assertNotNull(result);
927 assertTrue(!result.isEmpty());
928 assertEquals("new java.lang.Object()",