2 * Copyright (c) 2016 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
9 package org.opendaylight.yangtools.sal.binding.yang.types;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertTrue;
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.ConcreteType;
29 import org.opendaylight.yangtools.sal.binding.model.api.Enumeration;
30 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
31 import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType;
32 import org.opendaylight.yangtools.sal.binding.model.api.Restrictions;
33 import org.opendaylight.yangtools.sal.binding.model.api.Type;
34 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
35 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
36 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.Module;
40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
41 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
43 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
44 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
45 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
46 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
47 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
48 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
51 * Test suite for testing public methods in TypeProviderImpl class
53 * @see org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl
55 * @author Lukas Sedlak <lsedlak@cisco.com>
57 @RunWith(JUnit4.class)
58 public class TypeProviderTest {
60 private SchemaContext schemaContext;
61 private Set<Module> schemaModules;
62 private Module testTypeProviderModule;
65 private SchemaPath schemaPath;
68 private SchemaNode schemaNode;
71 public void setUp() throws SourceException, ReactorException {
72 MockitoAnnotations.initMocks(this);
73 schemaContext = TypeProviderModel.createTestContext();
74 assertNotNull(schemaContext);
75 schemaModules = schemaContext.getModules();
76 assertNotNull(schemaModules);
77 testTypeProviderModule = resolveModule(TypeProviderModel.TEST_TYPE_PROVIDER_MODULE_NAME);
78 assertNotNull(testTypeProviderModule);
81 private Module resolveModule(final String moduleName) {
82 assertNotNull(moduleName);
83 for (Module m : schemaModules) {
84 if (moduleName.equals(m.getName())) {
88 assertTrue("Unable to resolve module " + moduleName + ". No module present within Schema Context!" , false);
92 @Test(expected = IllegalArgumentException.class)
93 public void typeProviderInstanceWithNullSchemaContextTest() {
94 final TypeProvider provider = new TypeProviderImpl(null);
97 @Test(expected = IllegalArgumentException.class)
98 public void putReferencedTypeWithNullSchemaPathParamTest() {
99 final TypeProvider provider = new TypeProviderImpl(schemaContext);
101 ((TypeProviderImpl) provider).putReferencedType(null, null);
102 ((TypeProviderImpl) provider).putReferencedType(schemaPath, null);
105 @Test(expected = IllegalArgumentException.class)
106 public void putReferencedTypeWithNullRefTypeParamTest() {
107 final TypeProvider provider = new TypeProviderImpl(schemaContext);
109 ((TypeProviderImpl) provider).putReferencedType(schemaPath, null);
113 public void getAdditionalTypesTest() {
114 final TypeProvider provider = new TypeProviderImpl(schemaContext);
116 assertNotNull(((TypeProviderImpl) provider).getAdditionalTypes());
119 @Test(expected = IllegalArgumentException.class)
120 public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
121 final TypeProvider provider = new TypeProviderImpl(schemaContext);
123 provider.javaTypeForSchemaDefinitionType(null, null, null);
126 @Test(expected = IllegalArgumentException.class)
127 public void javaTypeForSchemaDefinitionTypeTypedefNullQNameTest() {
128 final TypeProvider provider = new TypeProviderImpl(schemaContext);
130 TestIntegerTypeDefinition testTypedef = new TestIntegerTypeDefinition();
131 provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
134 private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName, final String leafNodeName) {
135 final DataSchemaNode rootNode = module.getDataChildByName(containerName);
136 assertNotNull("Container foo is not present in root of module "+ module.getName(), rootNode);
137 assertTrue(rootNode instanceof DataNodeContainer);
139 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
140 final DataSchemaNode node = rootContainer.getDataChildByName(leafNodeName);
142 assertTrue(node instanceof LeafSchemaNode);
143 return (LeafSchemaNode) node;
146 private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module, final String containerName, final String leafListNodeName) {
147 final DataSchemaNode rootNode = module.getDataChildByName(containerName);
148 assertNotNull("Container foo is not present in root of module " + module.getName(), rootNode);
149 assertTrue(rootNode instanceof DataNodeContainer);
151 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
152 final DataSchemaNode node = rootContainer.getDataChildByName(leafListNodeName);
154 assertTrue(node instanceof LeafListSchemaNode);
155 return (LeafListSchemaNode) node;
159 public void javaTypeForSchemaDefinitionExtTypeTest() {
160 final TypeProvider provider = new TypeProviderImpl(schemaContext);
161 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
163 final TypeDefinition<?> leafType = leaf.getType();
164 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
165 assertNotNull(result);
166 assertTrue(result instanceof GeneratedTransferObject);
168 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
169 assertEquals("base-yang-types", genTO.getModuleName());
170 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
171 assertEquals("YangInt8", genTO.getName());
172 assertTrue(genTO.getProperties().size() == 1);
176 public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
177 final TypeProvider provider = new TypeProviderImpl(schemaContext);
178 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "restricted-int8-type");
180 final TypeDefinition<?> leafType = leaf.getType();
181 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
183 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
184 assertNotNull(result);
185 assertTrue(result instanceof GeneratedTransferObject);
187 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
188 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
189 assertEquals("YangInt8Restricted", genTO.getName());
190 assertTrue(genTO.getProperties().size() == 1);
191 final List<RangeConstraint> rangeConstraints = genTO.getRestrictions().getRangeConstraints();
193 assertTrue(!rangeConstraints.isEmpty());
194 final RangeConstraint constraint = rangeConstraints.get(0);
195 assertEquals(1, constraint.getMin().intValue());
196 assertEquals(100, constraint.getMax().intValue());
200 public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
201 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
203 final Module testTypeProvider = resolveModule("test-type-provider");
204 final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider, "empty-pattern-string");
206 assertNotNull(emptyPatternString);
207 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
209 Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
210 assertNotNull(result);
211 assertTrue(result instanceof GeneratedTransferObject);
213 result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
214 assertNotNull(result);
215 assertTrue(result instanceof GeneratedTransferObject);
218 private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
219 TypeDefinition<?> result = null;
220 final Set<TypeDefinition<?>> typeDefs = module.getTypeDefinitions();
221 for (final TypeDefinition<?> typedef : typeDefs) {
222 if (typedef.getQName().getLocalName().equals(typedefName)) {
230 * FIXME: Remove @Ignore annotation once the bug https://bugs.opendaylight.org/show_bug.cgi?id=1862 is fixed
234 public void bug1862RestrictedTypedefTransformationTest() {
235 final TypeProvider provider = new TypeProviderImpl(schemaContext);
236 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "bug-1862-restricted-typedef");
238 final TypeDefinition<?> leafType = leaf.getType();
239 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
240 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
241 assertNotNull(result);
242 assertTrue(result instanceof GeneratedTransferObject);
243 //TODO: complete test after bug 1862 is fixed
247 public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
248 final TypeProvider provider = new TypeProviderImpl(schemaContext);
249 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "resolve-enum-leaf");
250 TypeDefinition<?> leafType = leaf.getType();
251 Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
252 assertNotNull(result);
253 assertTrue(result instanceof Enumeration);
255 final Enumeration enumType = (Enumeration) result;
256 final List<Enumeration.Pair> enumValues = enumType.getValues();
257 assertTrue(!enumValues.isEmpty());
258 assertEquals("A", enumValues.get(0).getName());
259 assertEquals("B", enumValues.get(1).getName());
261 leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "resolve-direct-use-of-enum");
262 leafType = leaf.getType();
263 result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
264 assertNotNull(result);
265 assertTrue(result instanceof ConcreteType);
267 assertEquals("java.lang", result.getPackageName());
268 assertEquals("Enum", result.getName());
272 public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
273 final TypeProvider provider = new TypeProviderImpl(schemaContext);
274 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "bar", "leafref-value");
275 TypeDefinition<?> leafType = leaf.getType();
276 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
277 assertNotNull(leafrefResolvedType1);
278 assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
280 final Module module = resolveModule("test-type-provider-b");
281 final DataSchemaNode rootNode = module.getDataChildByName("id");
282 assertNotNull("leaf id is not present in root of module "+ module.getName(), rootNode);
283 assertTrue(rootNode instanceof LeafSchemaNode);
284 leaf = (LeafSchemaNode) rootNode;
285 leafType = leaf.getType();
287 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
288 assertNotNull(leafrefResolvedType2);
289 assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
293 public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
294 final TypeProvider provider = new TypeProviderImpl(schemaContext);
296 setReferencedTypeForTypeProvider(provider);
298 final Module module = resolveModule("test-type-provider-b");
300 final DataSchemaNode enumNode = module.getDataChildByName("enum");
301 assertNotNull("leaf enum is not present in root of module " + module.getName(), enumNode);
302 assertTrue(enumNode instanceof LeafSchemaNode);
303 LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
304 final TypeDefinition<?> leafType = leaf.getType();
306 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
307 assertNotNull(leafrefResolvedType1);
308 assertTrue(leafrefResolvedType1 instanceof ReferencedTypeImpl);
310 final DataSchemaNode enumListNode = module.getDataChildByName("enums");
311 assertNotNull("leaf-list enums is not present in root of module "+ module.getName(), enumNode);
312 assertTrue(enumListNode instanceof LeafListSchemaNode);
313 LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
314 TypeDefinition<?> leafListType = leafList.getType();
316 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
317 assertNotNull(leafrefResolvedType2);
318 assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
321 private void setReferencedTypeForTypeProvider(final TypeProvider provider) {
322 final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo",
323 "resolve-direct-use-of-enum");
324 final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
325 Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
327 Type refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getName());
328 ((TypeProviderImpl) provider).putReferencedType(enumLeafNode.getPath(), refType);
330 final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(testTypeProviderModule, "foo",
332 final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
333 enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
335 refType = new ReferencedTypeImpl(enumType.getPackageName(), enumType.getPackageName());
336 ((TypeProviderImpl) provider).putReferencedType(enumListNode.getPath(), refType);
340 public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
341 final TypeProvider provider = new TypeProviderImpl(schemaContext);
342 final Module module = resolveModule("test-type-provider-b");
344 final DataSchemaNode condLeaf = module.getDataChildByName("conditional-leafref");
345 assertNotNull("leaf conditional-leafref is not present in root of module "+ module.getName(), condLeaf);
346 assertTrue(condLeaf instanceof LeafSchemaNode);
347 LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
348 final TypeDefinition<?> leafType = leaf.getType();
350 final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
351 assertNotNull(resultType);
352 assertTrue(resultType instanceof ConcreteType);
353 assertEquals("java.lang", resultType.getPackageName());
354 assertEquals("Object", resultType.getName());
357 @Test(expected = IllegalArgumentException.class)
358 public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
359 final TypeProvider provider = new TypeProviderImpl(schemaContext);
360 final Module module = resolveModule("test-type-provider-b");
362 final DataSchemaNode condLeaf = module.getDataChildByName("unreslovable-leafref");
363 assertNotNull("leaf unreslovable-leafref is not present in root of module "+ module.getName(), condLeaf);
364 assertTrue(condLeaf instanceof LeafSchemaNode);
365 LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
366 final TypeDefinition<?> leafType = leaf.getType();
368 provider.javaTypeForSchemaDefinitionType(leafType, leaf);
371 @Test(expected = IllegalArgumentException.class)
372 public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
373 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
375 provider.provideTypeForLeafref(null, null);
378 @Test(expected = IllegalArgumentException.class)
379 public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
380 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
382 final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
383 provider.provideTypeForLeafref(leafrePath, schemaNode);
386 @Test(expected = IllegalStateException.class)
387 public void provideTypeForLeafrefWithNullParentModuleTest() {
388 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
389 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "bar", "leafref-value");
390 TypeDefinition<?> leafType = leaf.getType();
391 assertTrue(leafType instanceof LeafrefTypeDefinition);
392 provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, schemaNode);
396 public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
397 final TypeProvider provider = new TypeProviderImpl(schemaContext);
398 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "crypto");
399 final TypeDefinition<?> leafType = leaf.getType();
401 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
402 assertNotNull(result);
403 assertTrue(result instanceof ParameterizedType);
407 public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
408 final TypeProvider provider = new TypeProviderImpl(schemaContext);
409 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "use-of-unions", "simple-int-types-union");
410 final TypeDefinition<?> leafType = leaf.getType();
412 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
413 assertNotNull(result);
414 assertTrue(result instanceof GeneratedTransferObject);
415 assertEquals("YangUnion", result.getName());
416 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
420 public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
421 final TypeProvider provider = new TypeProviderImpl(schemaContext);
422 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "use-of-unions", "complex-union");
423 final TypeDefinition<?> leafType = leaf.getType();
425 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
426 assertNotNull(result);
427 assertTrue(result instanceof GeneratedTransferObject);
428 assertEquals("ComplexUnion", result.getName());
429 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
433 public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
434 final TypeProvider provider = new TypeProviderImpl(schemaContext);
435 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "use-of-unions", "complex-string-int-union");
436 final TypeDefinition<?> leafType = leaf.getType();
438 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
439 assertNotNull(result);
440 assertTrue(result instanceof GeneratedTransferObject);
441 assertEquals("ComplexStringIntUnion", result.getName());
442 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
446 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
447 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
449 final Module testTypeProvider = resolveModule("test-type-provider");
450 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-union");
452 assertNotNull(unionTypeDef);
453 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
454 GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
455 (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexUnionType", unionTypeDef);
457 assertNotNull(unionTypeBuilder);
459 GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
460 assertEquals("ComplexUnionType", unionType.getName());
462 unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
463 (UnionTypeDefinition)unionTypeDef.getBaseType(), "", unionTypeDef);
465 assertNotNull(unionTypeBuilder);
467 unionType = unionTypeBuilder.toInstance();
468 assertEquals("Union", unionType.getName());
470 unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
471 (UnionTypeDefinition)unionTypeDef.getBaseType(), null, unionTypeDef);
473 assertNotNull(unionTypeBuilder);
475 unionType = unionTypeBuilder.toInstance();
476 assertEquals("Union", unionType.getName());
480 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
481 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
483 final Module testTypeProvider = resolveModule("test-type-provider");
484 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-string-int-union");
486 assertNotNull(unionTypeDef);
487 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
488 final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef("test.package.name",
489 (UnionTypeDefinition)unionTypeDef.getBaseType(), "ComplexStringIntUnionType", unionTypeDef);
491 assertNotNull(unionTypeBuilder);
493 GeneratedTransferObject unionType = unionTypeBuilder.toInstance();
494 assertEquals("ComplexStringIntUnionType", unionType.getName());
498 public void generatedTypeForExtendedDefinitionTypeTest() {
499 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
501 final Module baseYangTypes = resolveModule("base-yang-types");
502 final Set<TypeDefinition<?>> typeDefs = baseYangTypes.getTypeDefinitions();
504 Type yangBoolean = null;
505 Type yangEmpty = null;
506 Type yangEnumeration = null;
507 Type yangInt8 = null;
508 Type yangInt8Restricted = null;
509 Type yangInt16 = null;
510 Type yangInt32 = null;
511 Type yangInt64 = null;
512 Type yangString = null;
513 Type yangDecimal = null;
514 Type yangUint8 = null;
515 Type yangUint16 = null;
516 Type yangUint32 = null;
517 Type yangUint64 = null;
518 Type yangUnion = null;
519 Type yangBinary = null;
520 Type yangBits = null;
521 Type yangInstanceIdentifier = null;
523 for (TypeDefinition<?> typedef : typeDefs) {
524 Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
525 if (type instanceof GeneratedTransferObject) {
526 if (type.getName().equals("YangBoolean")) {
528 } else if (type.getName().equals("YangEmpty")) {
530 } else if (type.getName().equals("YangInt8")) {
532 } else if (type.getName().equals("YangInt8Restricted")) {
533 yangInt8Restricted = type;
534 } else if (type.getName().equals("YangInt16")) {
536 } else if (type.getName().equals("YangInt32")) {
538 } else if (type.getName().equals("YangInt64")) {
540 } else if (type.getName().equals("YangString")) {
542 } else if (type.getName().equals("YangDecimal64")) {
544 } else if (type.getName().equals("YangUint8")) {
546 } else if (type.getName().equals("YangUint16")) {
548 } else if (type.getName().equals("YangUint32")) {
550 } else if (type.getName().equals("YangUint64")) {
552 } else if (type.getName().equals("YangUnion")) {
554 } else if (type.getName().equals("YangBinary")) {
556 } else if (type.getName().equals("YangInstanceIdentifier")) {
557 yangInstanceIdentifier = type;
558 } else if (type.getName().equals("YangBits")) {
561 } else if (type instanceof Enumeration) {
562 if (type.getName().equals("YangEnumeration")) {
563 yangEnumeration = type;
568 assertNotNull(yangBoolean);
569 assertNotNull(yangEmpty);
570 assertNotNull(yangEnumeration);
571 assertNotNull(yangInt8);
572 assertNotNull(yangInt8Restricted);
573 assertNotNull(yangInt16);
574 assertNotNull(yangInt32);
575 assertNotNull(yangInt64);
576 assertNotNull(yangString);
577 assertNotNull(yangDecimal);
578 assertNotNull(yangUint8);
579 assertNotNull(yangUint16);
580 assertNotNull(yangUint32);
581 assertNotNull(yangUint64);
582 assertNotNull(yangUnion);
583 assertNotNull(yangBinary);
584 assertNotNull(yangBits);
585 assertNotNull(yangInstanceIdentifier);
588 @Test(expected = IllegalArgumentException.class)
589 public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
590 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
591 provider.generatedTypeForExtendedDefinitionType(null, null);
594 @Test(expected = IllegalArgumentException.class)
595 public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
596 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
597 TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
598 provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
602 public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
603 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
605 final Module baseYangTypes = resolveModule("test-type-provider");
606 TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes, "extended-yang-int8");
607 assertNotNull(extYangInt8Typedef);
608 Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
609 assertNotNull(extType);
610 assertTrue(extType instanceof GeneratedTransferObject);
614 public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
615 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
617 final Module baseYangTypes = resolveModule("test-type-provider");
618 TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes, "bar-item-leafref-id");
619 assertNotNull(barItemLeafrefId);
620 Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
621 assertEquals(null, extType);
625 public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
626 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
628 final Module baseYangTypes = resolveModule("test-type-provider");
630 TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes, "aes-identityref-type");
632 assertNotNull(aesIdentityrefType);
633 Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
634 assertEquals(null, extType);
637 @Test(expected = IllegalArgumentException.class)
638 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
639 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
640 provider.provideGeneratedTOBuilderForBitsTypeDefinition("", null, "", "");
643 @Test(expected = IllegalArgumentException.class)
644 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithBasePackageNullTest() {
645 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
646 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
647 final TypeDefinition<?> leafType = leaf.getType();
648 provider.provideGeneratedTOBuilderForBitsTypeDefinition(null, leafType, "", "");
652 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNonBitsTypedefTest() {
653 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
655 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
656 final TypeDefinition<?> leafType = leaf.getType();
657 Type type = provider.provideGeneratedTOBuilderForBitsTypeDefinition("", leafType, "", "");
659 assertEquals(null, type);
663 public void getConstructorPropertyNameTest() {
664 final TypeProvider provider = new TypeProviderImpl(schemaContext);
666 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
667 final TypeDefinition<?> leafType = leaf.getType();
669 final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
670 assertEquals("value", ctorPropertyName);
672 final String emptyStringName = provider.getConstructorPropertyName(leaf);
673 assertTrue(emptyStringName.isEmpty());
677 public void getParamNameFromTypeTest() {
678 final TypeProvider provider = new TypeProviderImpl(schemaContext);
680 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "foo", "yang-int8-type");
681 final TypeDefinition<?> leafType = leaf.getType();
683 final String paramName = provider.getParamNameFromType(leafType);
684 assertEquals("yangInt8", paramName);
688 public void addUnitsToGenTOTest() {
689 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
691 GeneratedTOBuilder builder = new GeneratedTOBuilderImpl("test.package", "TestBuilder");
693 TypeProviderImpl.addUnitsToGenTO(builder, null);
694 GeneratedTransferObject genTO = builder.toInstance();
695 assertTrue(genTO.getConstantDefinitions().isEmpty());
697 TypeProviderImpl.addUnitsToGenTO(builder, "");
698 genTO = builder.toInstance();
699 assertTrue(genTO.getConstantDefinitions().isEmpty());
701 TypeProviderImpl.addUnitsToGenTO(builder, "125");
702 genTO = builder.toInstance();
703 assertTrue(!genTO.getConstantDefinitions().isEmpty());
704 assertEquals(1, genTO.getConstantDefinitions().size());
705 assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
706 assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
709 @Test(expected = NullPointerException.class)
710 public void getTypeDefaultConstructionLeafTypeNullTest() {
711 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
712 TestLeafSchemaNode leafSchemaNode = new TestLeafSchemaNode();
713 provider.getTypeDefaultConstruction(leafSchemaNode, null);
716 @Test(expected = NullPointerException.class)
717 public void getTypeDefaultConstructionDefaultValueNullTest() {
718 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
719 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
720 provider.getTypeDefaultConstruction(leaf, null);
723 private LeafSchemaNode provideLeafForGetDefaultConstructionTestCase(final String leafName) {
724 return provideLeafNodeFromTopLevelContainer(testTypeProviderModule, "construction-type-test",
728 @Test(expected = UnsupportedOperationException.class)
729 public void getTypeDefaultConstructionDefaultValueForInstanceIdentifierTest() {
730 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
731 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("foo-container-id");
732 provider.getTypeDefaultConstruction(leaf, "NAN");
735 @Test(expected = UnsupportedOperationException.class)
736 public void getTypeDefaultConstructionDefaultValueForIdentityrefTest() {
737 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
738 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("aes-identityref-type");
739 provider.getTypeDefaultConstruction(leaf, "NAN");
743 public void getTypeDefaultConstructionDefaultValueTest() {
744 final TypeProviderImpl provider = new TypeProviderImpl(schemaContext);
746 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
747 String 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.YangBoolean(new java.lang.Boolean(\"true\"))",
753 leaf = provideLeafForGetDefaultConstructionTestCase("yang-empty");
754 result = provider.getTypeDefaultConstruction(leaf, "true");
755 assertNotNull(result);
756 assertTrue(!result.isEmpty());
757 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEmpty(new java.lang.Boolean(\"true\"))",
760 leaf = provideLeafForGetDefaultConstructionTestCase("yang-enumeration");
761 result = provider.getTypeDefaultConstruction(leaf, "a");
762 assertNotNull(result);
763 assertTrue(!result.isEmpty());
764 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEnumeration.A",
767 leaf = provideLeafForGetDefaultConstructionTestCase("direct-use-of-enum");
768 result = provider.getTypeDefaultConstruction(leaf, "y");
769 assertNotNull(result);
770 assertTrue(!result.isEmpty());
771 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.construction.type.test.DirectUseOfEnum.Y",
774 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8");
775 result = provider.getTypeDefaultConstruction(leaf, "17");
776 assertNotNull(result);
777 assertTrue(!result.isEmpty());
778 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(new java.lang.Byte(\"17\"))",
781 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8-restricted");
782 result = provider.getTypeDefaultConstruction(leaf, "99");
783 assertNotNull(result);
784 assertTrue(!result.isEmpty());
785 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8Restricted(new java.lang.Byte(\"99\"))",
788 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int16");
789 result = provider.getTypeDefaultConstruction(leaf, "1024");
790 assertNotNull(result);
791 assertTrue(!result.isEmpty());
792 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(new java.lang.Short(\"1024\"))",
795 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int32");
796 result = provider.getTypeDefaultConstruction(leaf, "1048576");
797 assertNotNull(result);
798 assertTrue(!result.isEmpty());
799 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt32(new java.lang.Integer(\"1048576\"))",
802 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int64");
803 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
804 assertNotNull(result);
805 assertTrue(!result.isEmpty());
806 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt64(new java.lang.Long(\"1099511627776\"))",
809 leaf = provideLeafForGetDefaultConstructionTestCase("yang-string");
810 result = provider.getTypeDefaultConstruction(leaf, "TEST");
811 assertNotNull(result);
812 assertTrue(!result.isEmpty());
813 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangString(\"TEST\")",
816 leaf = provideLeafForGetDefaultConstructionTestCase("yang-decimal64");
817 result = provider.getTypeDefaultConstruction(leaf, "1274.25");
818 assertNotNull(result);
819 assertTrue(!result.isEmpty());
820 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangDecimal64(new java.math.BigDecimal(\"1274.25\"))",
823 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint8");
824 result = provider.getTypeDefaultConstruction(leaf, "128");
825 assertNotNull(result);
826 assertTrue(!result.isEmpty());
827 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint8(new java.lang.Short(\"128\"))",
830 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint16");
831 result = provider.getTypeDefaultConstruction(leaf, "1048576");
832 assertNotNull(result);
833 assertTrue(!result.isEmpty());
834 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint16(new java.lang.Integer(\"1048576\"))",
837 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint32");
838 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
839 assertNotNull(result);
840 assertTrue(!result.isEmpty());
841 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint32(new java.lang.Long(\"1099511627776\"))",
844 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint64");
845 result = provider.getTypeDefaultConstruction(leaf, "1208925819614629174706176");
846 assertNotNull(result);
847 assertTrue(!result.isEmpty());
848 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint64(new java.math.BigInteger(\"1208925819614629174706176\"))",
851 //FIXME: Is this correct scenario and correct result?
852 leaf = provideLeafForGetDefaultConstructionTestCase("complex-union");
853 result = provider.getTypeDefaultConstruction(leaf, "75");
854 assertNotNull(result);
855 assertTrue(!result.isEmpty());
856 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexUnion(\"null\".toCharArray())",
859 //FIXME: Is this correct scenario and correct result?
860 leaf = provideLeafForGetDefaultConstructionTestCase("complex-string-int-union");
861 result = provider.getTypeDefaultConstruction(leaf, "TEST_UNION_STRING_DEFAULT");
862 assertNotNull(result);
863 assertTrue(!result.isEmpty());
864 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexStringIntUnion(\"null\".toCharArray())",
867 leaf = provideLeafForGetDefaultConstructionTestCase("simple-int-types-union");
868 result = provider.getTypeDefaultConstruction(leaf, "2048");
869 assertNotNull(result);
870 assertTrue(!result.isEmpty());
871 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUnion(\"null\".toCharArray())",
875 leaf = provideLeafForGetDefaultConstructionTestCase("direct-union-leaf");
876 result = provider.getTypeDefaultConstruction(leaf);
877 assertNotNull(result);
878 assertTrue(!result.isEmpty());
879 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.DirectUnionLeaf(\"128\".toCharArray())",
882 final Module module = resolveModule("test-type-provider");
883 DataSchemaNode rootNode = module.getDataChildByName("root-union-leaf");
884 assertNotNull("leaf root-union-leaf is not present in root of module "+ module.getName(), rootNode);
885 assertTrue(rootNode instanceof LeafSchemaNode);
886 leaf = (LeafSchemaNode) rootNode;
887 result = provider.getTypeDefaultConstruction(leaf);
888 assertNotNull(result);
889 assertTrue(!result.isEmpty());
890 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootUnionLeaf(\"256\".toCharArray())",
893 leaf = provideLeafForGetDefaultConstructionTestCase("yang-binary");
894 result = provider.getTypeDefaultConstruction(leaf, "0xffffff");
895 assertNotNull(result);
896 assertTrue(!result.isEmpty());
897 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBinary(new byte[] {-45, 23, -33, 125, -9, -33})",
900 rootNode = module.getDataChildByName("root-bits-leaf");
901 assertNotNull("leaf bits-leaf is not present in root of module "+ module.getName(), rootNode);
902 assertTrue(rootNode instanceof LeafSchemaNode);
903 leaf = (LeafSchemaNode) rootNode;
904 result = provider.getTypeDefaultConstruction(leaf);
905 assertNotNull(result);
906 assertTrue(!result.isEmpty());
907 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootBitsLeaf(false, true, false)",
910 leaf = provideLeafForGetDefaultConstructionTestCase("yang-bits");
911 result = provider.getTypeDefaultConstruction(leaf, "10-Mb-only");
912 assertNotNull(result);
913 assertTrue(!result.isEmpty());
914 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBits(true, false, false)",
917 leaf = provideLeafForGetDefaultConstructionTestCase("bar-id");
918 result = provider.getTypeDefaultConstruction(leaf, "128");
919 assertNotNull(result);
920 assertTrue(!result.isEmpty());
921 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(new java.lang.Short(\"128\"))",
924 leaf = provideLeafForGetDefaultConstructionTestCase("foo-leafref-value");
925 result = provider.getTypeDefaultConstruction(leaf, "32");
926 assertNotNull(result);
927 assertTrue(!result.isEmpty());
928 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(new java.lang.Byte(\"32\"))",
931 leaf = provideLeafForGetDefaultConstructionTestCase("foo-cond-bar-item");
932 result = provider.getTypeDefaultConstruction(leaf, "10");
933 assertNotNull(result);
934 assertTrue(!result.isEmpty());
935 assertEquals("new java.lang.Object()",