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.mdsal.binding.yang.types;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertTrue;
14 import static org.mockito.Mockito.doReturn;
16 import com.google.common.collect.Range;
17 import java.util.List;
18 import java.util.Optional;
20 import org.junit.Before;
21 import org.junit.Ignore;
22 import org.junit.Test;
23 import org.junit.runner.RunWith;
24 import org.junit.runners.JUnit4;
25 import org.mockito.Mock;
26 import org.mockito.MockitoAnnotations;
27 import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
28 import org.opendaylight.mdsal.binding.model.api.ConcreteType;
29 import org.opendaylight.mdsal.binding.model.api.Enumeration;
30 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
31 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
32 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
33 import org.opendaylight.mdsal.binding.model.api.Restrictions;
34 import org.opendaylight.mdsal.binding.model.api.Type;
35 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
36 import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
37 import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl;
38 import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
39 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
40 import org.opendaylight.yangtools.yang.common.QName;
41 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
42 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.Module;
46 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
47 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
48 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
49 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
50 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
51 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
52 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
53 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
54 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
57 * Test suite for testing public methods in TypeProviderImpl class
59 * @see org.opendaylight.mdsal.binding.yang.types.TypeProviderImpl
61 * @author Lukas Sedlak <lsedlak@cisco.com>
63 @RunWith(JUnit4.class)
64 public class TypeProviderTest {
66 private SchemaContext schemaContext;
67 private Set<Module> schemaModules;
68 private Module testTypeProviderModule;
71 private SchemaPath schemaPath;
74 private SchemaNode schemaNode;
77 public void setUp() throws SourceException, ReactorException {
78 MockitoAnnotations.initMocks(this);
79 this.schemaContext = TypeProviderModel.createTestContext();
80 assertNotNull(this.schemaContext);
81 this.schemaModules = this.schemaContext.getModules();
82 assertNotNull(this.schemaModules);
83 this.testTypeProviderModule = resolveModule(TypeProviderModel.TEST_TYPE_PROVIDER_MODULE_NAME);
84 assertNotNull(this.testTypeProviderModule);
87 private Module resolveModule(final String moduleName) {
88 assertNotNull(moduleName);
89 for (final Module m : this.schemaModules) {
90 if (moduleName.equals(m.getName())) {
94 assertTrue("Unable to resolve module " + moduleName + ". No module present within Schema Context!" , false);
98 @Test(expected = IllegalArgumentException.class)
99 public void typeProviderInstanceWithNullSchemaContextTest() {
100 new RuntimeTypeProvider(null);
103 @Test(expected = IllegalArgumentException.class)
104 public void putReferencedTypeWithNullSchemaPathParamTest() {
105 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
107 provider.putReferencedType(null, null);
108 provider.putReferencedType(this.schemaPath, null);
111 @Test(expected = IllegalArgumentException.class)
112 public void putReferencedTypeWithNullRefTypeParamTest() {
113 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
115 provider.putReferencedType(this.schemaPath, null);
119 public void getAdditionalTypesTest() {
120 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
122 assertNotNull(provider.getAdditionalTypes());
125 @Test(expected = IllegalArgumentException.class)
126 public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
127 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
129 provider.javaTypeForSchemaDefinitionType(null, null, null);
132 @Test(expected = IllegalArgumentException.class)
133 public void javaTypeForSchemaDefinitionTypeTypedefNullQNameTest() {
134 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
136 final TestIntegerTypeDefinition testTypedef = new TestIntegerTypeDefinition();
137 provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
140 private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName, final String leafNodeName) {
141 final QName containerNode = QName.create(module.getQNameModule(), containerName);
142 final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
143 assertNotNull("Container foo is not present in root of module "+ module.getName(), rootNode);
144 assertTrue(rootNode instanceof DataNodeContainer);
146 final QName leafNode = QName.create(module.getQNameModule(), leafNodeName);
147 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
148 final DataSchemaNode node = rootContainer.getDataChildByName(leafNode);
150 assertTrue(node instanceof LeafSchemaNode);
151 return (LeafSchemaNode) node;
154 private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module, final String containerName, final String leafListNodeName) {
155 final QName containerNode = QName.create(module.getQNameModule(), containerName);
156 final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
157 assertNotNull("Container foo is not present in root of module " + module.getName(), rootNode);
158 assertTrue(rootNode instanceof DataNodeContainer);
160 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
161 final QName leafListNode = QName.create(module.getQNameModule(), leafListNodeName);
162 final DataSchemaNode node = rootContainer.getDataChildByName(leafListNode);
164 assertTrue(node instanceof LeafListSchemaNode);
165 return (LeafListSchemaNode) node;
169 public void javaTypeForSchemaDefinitionExtTypeTest() {
170 final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
171 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
173 final TypeDefinition<?> leafType = leaf.getType();
174 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
175 assertNotNull(result);
176 assertTrue(result instanceof GeneratedTransferObject);
178 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
179 assertEquals("base-yang-types", genTO.getModuleName());
180 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
181 assertEquals("YangInt8", genTO.getName());
182 assertEquals(1, genTO.getProperties().size());
186 public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
187 final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
188 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "restricted-int8-type");
190 final TypeDefinition<?> leafType = leaf.getType();
191 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
193 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
194 assertNotNull(result);
195 assertTrue(result instanceof GeneratedTransferObject);
197 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
198 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
199 assertEquals("YangInt8Restricted", genTO.getName());
200 assertEquals(1, genTO.getProperties().size());
201 final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
203 assertTrue(rangeConstraints.isPresent());
204 final Range<?> constraint = rangeConstraints.get().getAllowedRanges().asRanges().iterator().next();
205 assertEquals((byte) 1, constraint.lowerEndpoint());
206 assertEquals((byte) 100, constraint.upperEndpoint());
210 public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
211 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
213 final Module testTypeProvider = resolveModule("test-type-provider");
214 final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider, "empty-pattern-string");
216 assertNotNull(emptyPatternString);
217 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
219 Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
220 assertNotNull(result);
221 assertTrue(result instanceof GeneratedTransferObject);
223 result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
224 assertNotNull(result);
225 assertTrue(result instanceof GeneratedTransferObject);
228 private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
229 TypeDefinition<?> result = null;
230 final Set<TypeDefinition<?>> typeDefs = module.getTypeDefinitions();
231 for (final TypeDefinition<?> typedef : typeDefs) {
232 if (typedef.getQName().getLocalName().equals(typedefName)) {
240 * FIXME: Remove @Ignore annotation once the bug https://bugs.opendaylight.org/show_bug.cgi?id=1862 is fixed
244 public void bug1862RestrictedTypedefTransformationTest() {
245 final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
246 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
247 "bug-1862-restricted-typedef");
249 final TypeDefinition<?> leafType = leaf.getType();
250 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
251 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
252 assertNotNull(result);
253 assertTrue(result instanceof GeneratedTransferObject);
254 //TODO: complete test after bug 1862 is fixed
258 public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
259 final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
260 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
261 "resolve-enum-leaf");
262 TypeDefinition<?> leafType = leaf.getType();
263 Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
264 assertNotNull(result);
265 assertTrue(result instanceof Enumeration);
267 final Enumeration enumType = (Enumeration) result;
268 final List<Enumeration.Pair> enumValues = enumType.getValues();
269 assertTrue(!enumValues.isEmpty());
270 assertEquals("a", enumValues.get(0).getName());
271 assertEquals("b", enumValues.get(1).getName());
272 assertEquals("A", enumValues.get(0).getMappedName());
273 assertEquals("B", enumValues.get(1).getMappedName());
275 leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "resolve-direct-use-of-enum");
276 leafType = leaf.getType();
277 result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
278 assertNotNull(result);
279 assertTrue(result instanceof ConcreteType);
281 assertEquals("java.lang", result.getPackageName());
282 assertEquals("Enum", result.getName());
286 public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
287 final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
288 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "bar", "leafref-value");
289 TypeDefinition<?> leafType = leaf.getType();
290 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
291 assertNotNull(leafrefResolvedType1);
292 assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
294 final Module module = resolveModule("test-type-provider-b");
295 final QName leafNode = QName.create(module.getQNameModule(), "id");
296 final DataSchemaNode rootNode = module.getDataChildByName(leafNode);
297 assertNotNull("leaf id is not present in root of module "+ module.getName(), rootNode);
298 assertTrue(rootNode instanceof LeafSchemaNode);
299 leaf = (LeafSchemaNode) rootNode;
300 leafType = leaf.getType();
302 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
303 assertNotNull(leafrefResolvedType2);
304 assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
308 public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
309 final AbstractTypeProvider provider = new CodegenTypeProvider(this.schemaContext);
311 setReferencedTypeForTypeProvider(provider);
313 final Module module = resolveModule("test-type-provider-b");
315 final QName leafNode = QName.create(module.getQNameModule(), "enum");
316 final DataSchemaNode enumNode = module.getDataChildByName(leafNode);
317 assertNotNull("leaf enum is not present in root of module " + module.getName(), enumNode);
318 assertTrue(enumNode instanceof LeafSchemaNode);
319 final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
320 final TypeDefinition<?> leafType = leaf.getType();
322 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
323 assertNotNull(leafrefResolvedType1);
324 assertTrue(leafrefResolvedType1 instanceof ReferencedTypeImpl);
326 final QName leafListNode = QName.create(module.getQNameModule(), "enums");
327 final DataSchemaNode enumListNode = module.getDataChildByName(leafListNode);
328 assertNotNull("leaf-list enums is not present in root of module " + module.getName(), enumNode);
329 assertTrue(enumListNode instanceof LeafListSchemaNode);
330 final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
331 final TypeDefinition<?> leafListType = leafList.getType();
333 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
334 assertNotNull(leafrefResolvedType2);
335 assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
338 private void setReferencedTypeForTypeProvider(final AbstractTypeProvider provider) {
339 final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
340 "resolve-direct-use-of-enum");
341 final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
342 Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
344 Type refType = new ReferencedTypeImpl(enumType.getIdentifier());
345 provider.putReferencedType(enumLeafNode.getPath(), refType);
347 final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(this.testTypeProviderModule,
348 "foo", "list-of-enums");
349 final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
350 enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
352 refType = new ReferencedTypeImpl(enumType.getIdentifier());
353 provider.putReferencedType(enumListNode.getPath(), refType);
357 public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
358 final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
359 final Module module = resolveModule("test-type-provider-b");
361 final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
362 final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
363 assertNotNull("leaf conditional-leafref is not present in root of module "+ module.getName(), condLeaf);
364 assertTrue(condLeaf instanceof LeafSchemaNode);
365 final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
366 final TypeDefinition<?> leafType = leaf.getType();
368 final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
369 assertNotNull(resultType);
370 assertTrue(resultType instanceof ConcreteType);
371 assertEquals("java.lang", resultType.getPackageName());
372 assertEquals("Object", resultType.getName());
375 @Test(expected = IllegalArgumentException.class)
376 public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
377 final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
378 final Module module = resolveModule("test-type-provider-b");
380 final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
381 final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
382 assertNotNull("leaf unreslovable-leafref is not present in root of module "+ module.getName(), condLeaf);
383 assertTrue(condLeaf instanceof LeafSchemaNode);
384 final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
385 final TypeDefinition<?> leafType = leaf.getType();
387 provider.javaTypeForSchemaDefinitionType(leafType, leaf);
390 @Test(expected = IllegalArgumentException.class)
391 public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
392 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
394 provider.provideTypeForLeafref(null, null);
397 @Test(expected = IllegalArgumentException.class)
398 public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
399 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
401 final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
402 provider.provideTypeForLeafref(leafrePath, this.schemaNode);
405 @Test(expected = IllegalStateException.class)
406 public void provideTypeForLeafrefWithNullParentModuleTest() {
407 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
408 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "bar",
410 final TypeDefinition<?> leafType = leaf.getType();
411 assertTrue(leafType instanceof LeafrefTypeDefinition);
412 doReturn(null).when(this.schemaNode).getPath();
413 provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, this.schemaNode);
417 public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
418 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
419 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "crypto");
420 final TypeDefinition<?> leafType = leaf.getType();
422 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
423 assertNotNull(result);
424 assertTrue(result instanceof ParameterizedType);
428 public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
429 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
430 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "simple-int-types-union");
431 final TypeDefinition<?> leafType = leaf.getType();
433 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
434 assertNotNull(result);
435 assertTrue(result instanceof GeneratedTransferObject);
436 assertEquals("YangUnion", result.getName());
437 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
441 public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
442 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
443 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-union");
444 final TypeDefinition<?> leafType = leaf.getType();
446 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
447 assertNotNull(result);
448 assertTrue(result instanceof GeneratedTransferObject);
449 assertEquals("ComplexUnion", result.getName());
450 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
454 public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
455 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
456 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-string-int-union");
457 final TypeDefinition<?> leafType = leaf.getType();
459 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
460 assertNotNull(result);
461 assertTrue(result instanceof GeneratedTransferObject);
462 assertEquals("ComplexStringIntUnion", result.getName());
463 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
467 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
468 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
470 final Module testTypeProvider = resolveModule("test-type-provider");
471 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider, "complex-union");
473 assertNotNull(unionTypeDef);
474 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
475 GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
476 JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
477 (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
479 assertNotNull(unionTypeBuilder);
481 GeneratedTransferObject unionType = unionTypeBuilder.build();
482 assertEquals("ComplexUnion", unionType.getName());
486 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
487 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
489 final Module testTypeProvider = resolveModule("test-type-provider");
490 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(testTypeProvider,
491 "complex-string-int-union");
493 assertNotNull(unionTypeDef);
494 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
495 final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
496 JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
497 (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
499 assertNotNull(unionTypeBuilder);
501 final GeneratedTransferObject unionType = unionTypeBuilder.build();
502 assertEquals("ComplexStringIntUnion", unionType.getName());
506 public void generatedTypeForExtendedDefinitionTypeTest() {
507 final AbstractTypeProvider provider = new CodegenTypeProvider(this.schemaContext);
509 final Module baseYangTypes = resolveModule("base-yang-types");
510 final Set<TypeDefinition<?>> typeDefs = baseYangTypes.getTypeDefinitions();
512 Type yangBoolean = null;
513 Type yangEmpty = null;
514 Type yangEnumeration = null;
515 Type yangInt8 = null;
516 Type yangInt8Restricted = null;
517 Type yangInt16 = null;
518 Type yangInt32 = null;
519 Type yangInt64 = null;
520 Type yangString = null;
521 Type yangDecimal = null;
522 Type yangUint8 = null;
523 Type yangUint16 = null;
524 Type yangUint32 = null;
525 Type yangUint64 = null;
526 Type yangUnion = null;
527 Type yangBinary = null;
528 Type yangBits = null;
529 Type yangInstanceIdentifier = null;
531 for (final TypeDefinition<?> typedef : typeDefs) {
532 final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
533 if (type instanceof GeneratedTransferObject) {
534 if (type.getName().equals("YangBoolean")) {
536 } else if (type.getName().equals("YangEmpty")) {
538 } else if (type.getName().equals("YangInt8")) {
540 } else if (type.getName().equals("YangInt8Restricted")) {
541 yangInt8Restricted = type;
542 } else if (type.getName().equals("YangInt16")) {
544 } else if (type.getName().equals("YangInt32")) {
546 } else if (type.getName().equals("YangInt64")) {
548 } else if (type.getName().equals("YangString")) {
550 } else if (type.getName().equals("YangDecimal64")) {
552 } else if (type.getName().equals("YangUint8")) {
554 } else if (type.getName().equals("YangUint16")) {
556 } else if (type.getName().equals("YangUint32")) {
558 } else if (type.getName().equals("YangUint64")) {
560 } else if (type.getName().equals("YangUnion")) {
562 } else if (type.getName().equals("YangBinary")) {
564 } else if (type.getName().equals("YangInstanceIdentifier")) {
565 yangInstanceIdentifier = type;
566 } else if (type.getName().equals("YangBits")) {
569 } else if (type instanceof Enumeration) {
570 if (type.getName().equals("YangEnumeration")) {
571 yangEnumeration = type;
576 assertNotNull(yangBoolean);
577 assertNotNull(yangEmpty);
578 assertNotNull(yangEnumeration);
579 assertNotNull(yangInt8);
580 assertNotNull(yangInt8Restricted);
581 assertNotNull(yangInt16);
582 assertNotNull(yangInt32);
583 assertNotNull(yangInt64);
584 assertNotNull(yangString);
585 assertNotNull(yangDecimal);
586 assertNotNull(yangUint8);
587 assertNotNull(yangUint16);
588 assertNotNull(yangUint32);
589 assertNotNull(yangUint64);
590 assertNotNull(yangUnion);
591 assertNotNull(yangBinary);
592 assertNotNull(yangBits);
593 assertNotNull(yangInstanceIdentifier);
596 @Test(expected = IllegalArgumentException.class)
597 public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
598 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
599 provider.generatedTypeForExtendedDefinitionType(null, null);
602 @Test(expected = IllegalArgumentException.class)
603 public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
604 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
605 final TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
606 provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
610 public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
611 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
613 final Module baseYangTypes = resolveModule("test-type-provider");
614 final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes,
615 "extended-yang-int8");
616 assertNotNull(extYangInt8Typedef);
617 final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
618 assertNotNull(extType);
619 assertTrue(extType instanceof GeneratedTransferObject);
623 public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
624 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
626 final Module baseYangTypes = resolveModule("test-type-provider");
627 final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes, "bar-item-leafref-id");
628 assertNotNull(barItemLeafrefId);
629 final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
630 assertEquals(null, extType);
634 public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
635 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
637 final Module baseYangTypes = resolveModule("test-type-provider");
639 final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes,
640 "aes-identityref-type");
642 assertNotNull(aesIdentityrefType);
643 final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
644 assertEquals(null, extType);
647 @Test(expected = NullPointerException.class)
648 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
649 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
650 provider.provideGeneratedTOBuilderForBitsTypeDefinition(JavaTypeName.create("foo", "foo"), null, "foo");
654 public void getConstructorPropertyNameTest() {
655 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
657 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
659 final TypeDefinition<?> leafType = leaf.getType();
661 final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
662 assertEquals("value", ctorPropertyName);
664 final String emptyStringName = provider.getConstructorPropertyName(leaf);
665 assertTrue(emptyStringName.isEmpty());
669 public void getParamNameFromTypeTest() {
670 final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
672 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
674 final TypeDefinition<?> leafType = leaf.getType();
676 final String paramName = provider.getParamNameFromType(leafType);
677 assertEquals("yangInt8", paramName);
681 public void addUnitsToGenTOTest() {
682 final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(
683 JavaTypeName.create("test.package", "TestBuilder"));
685 CodegenTypeProvider.addUnitsToGenTO(builder, null);
686 GeneratedTransferObject genTO = builder.build();
687 assertTrue(genTO.getConstantDefinitions().isEmpty());
689 CodegenTypeProvider.addUnitsToGenTO(builder, "");
690 genTO = builder.build();
691 assertTrue(genTO.getConstantDefinitions().isEmpty());
693 CodegenTypeProvider.addUnitsToGenTO(builder, "125");
694 genTO = builder.build();
695 assertTrue(!genTO.getConstantDefinitions().isEmpty());
696 assertEquals(1, genTO.getConstantDefinitions().size());
697 assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
698 assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
701 @Test(expected = NullPointerException.class)
702 public void getTypeDefaultConstructionLeafTypeNullTest() {
703 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
704 final TestLeafSchemaNode leafSchemaNode = new TestLeafSchemaNode();
705 provider.getTypeDefaultConstruction(leafSchemaNode, null);
708 @Test(expected = NullPointerException.class)
709 public void getTypeDefaultConstructionDefaultValueNullTest() {
710 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
711 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
712 provider.getTypeDefaultConstruction(leaf, null);
715 private LeafSchemaNode provideLeafForGetDefaultConstructionTestCase(final String leafName) {
716 return provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "construction-type-test",
720 @Test(expected = UnsupportedOperationException.class)
721 public void getTypeDefaultConstructionDefaultValueForInstanceIdentifierTest() {
722 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
723 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("foo-container-id");
724 provider.getTypeDefaultConstruction(leaf, "NAN");
727 @Test(expected = UnsupportedOperationException.class)
728 public void getTypeDefaultConstructionDefaultValueForIdentityrefTest() {
729 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
730 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("aes-identityref-type");
731 provider.getTypeDefaultConstruction(leaf, "NAN");
735 public void getTypeDefaultConstructionDefaultValueTest() {
736 final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
738 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
739 String result = provider.getTypeDefaultConstruction(leaf, "true");
740 assertNotNull(result);
741 assertTrue(!result.isEmpty());
742 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBoolean(java.lang.Boolean.TRUE)",
745 leaf = provideLeafForGetDefaultConstructionTestCase("yang-empty");
746 result = provider.getTypeDefaultConstruction(leaf, "true");
747 assertNotNull(result);
748 assertTrue(!result.isEmpty());
749 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEmpty(java.lang.Boolean.TRUE)",
752 leaf = provideLeafForGetDefaultConstructionTestCase("yang-enumeration");
753 result = provider.getTypeDefaultConstruction(leaf, "a");
754 assertNotNull(result);
755 assertTrue(!result.isEmpty());
756 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEnumeration.A",
759 leaf = provideLeafForGetDefaultConstructionTestCase("direct-use-of-enum");
760 result = provider.getTypeDefaultConstruction(leaf, "y");
761 assertNotNull(result);
762 assertTrue(!result.isEmpty());
763 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.construction.type.test.DirectUseOfEnum.Y",
766 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8");
767 result = provider.getTypeDefaultConstruction(leaf, "17");
768 assertNotNull(result);
769 assertTrue(!result.isEmpty());
770 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"17\"))",
773 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8-restricted");
774 result = provider.getTypeDefaultConstruction(leaf, "99");
775 assertNotNull(result);
776 assertTrue(!result.isEmpty());
777 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8Restricted(java.lang.Byte.valueOf(\"99\"))",
780 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int16");
781 result = provider.getTypeDefaultConstruction(leaf, "1024");
782 assertNotNull(result);
783 assertTrue(!result.isEmpty());
784 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"1024\"))",
787 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int32");
788 result = provider.getTypeDefaultConstruction(leaf, "1048576");
789 assertNotNull(result);
790 assertTrue(!result.isEmpty());
791 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt32(java.lang.Integer.valueOf(\"1048576\"))",
794 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int64");
795 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
796 assertNotNull(result);
797 assertTrue(!result.isEmpty());
798 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt64(java.lang.Long.valueOf(\"1099511627776\"))",
801 leaf = provideLeafForGetDefaultConstructionTestCase("yang-string");
802 result = provider.getTypeDefaultConstruction(leaf, "TEST");
803 assertNotNull(result);
804 assertTrue(!result.isEmpty());
805 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangString(\"TEST\")",
808 leaf = provideLeafForGetDefaultConstructionTestCase("yang-decimal64");
809 result = provider.getTypeDefaultConstruction(leaf, "1274.25");
810 assertNotNull(result);
811 assertTrue(!result.isEmpty());
812 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangDecimal64(new java.math.BigDecimal(\"1274.25\"))",
815 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint8");
816 result = provider.getTypeDefaultConstruction(leaf, "128");
817 assertNotNull(result);
818 assertTrue(!result.isEmpty());
819 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint8(java.lang.Short.valueOf(\"128\"))",
822 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint16");
823 result = provider.getTypeDefaultConstruction(leaf, "1048576");
824 assertNotNull(result);
825 assertTrue(!result.isEmpty());
826 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint16(java.lang.Integer.valueOf(\"1048576\"))",
829 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint32");
830 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
831 assertNotNull(result);
832 assertTrue(!result.isEmpty());
833 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint32(java.lang.Long.valueOf(\"1099511627776\"))",
836 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint64");
837 result = provider.getTypeDefaultConstruction(leaf, "1208925819614629174706176");
838 assertNotNull(result);
839 assertTrue(!result.isEmpty());
840 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint64(new java.math.BigInteger(\"1208925819614629174706176\"))",
843 //FIXME: Is this correct scenario and correct result?
844 leaf = provideLeafForGetDefaultConstructionTestCase("complex-union");
845 result = provider.getTypeDefaultConstruction(leaf, "75");
846 assertNotNull(result);
847 assertTrue(!result.isEmpty());
848 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexUnion(\"null\".toCharArray())",
851 //FIXME: Is this correct scenario and correct result?
852 leaf = provideLeafForGetDefaultConstructionTestCase("complex-string-int-union");
853 result = provider.getTypeDefaultConstruction(leaf, "TEST_UNION_STRING_DEFAULT");
854 assertNotNull(result);
855 assertTrue(!result.isEmpty());
856 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexStringIntUnion(\"null\".toCharArray())",
859 leaf = provideLeafForGetDefaultConstructionTestCase("simple-int-types-union");
860 result = provider.getTypeDefaultConstruction(leaf, "2048");
861 assertNotNull(result);
862 assertTrue(!result.isEmpty());
863 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUnion(\"null\".toCharArray())",
867 leaf = provideLeafForGetDefaultConstructionTestCase("direct-union-leaf");
868 result = provider.getTypeDefaultConstruction(leaf);
869 assertNotNull(result);
870 assertTrue(!result.isEmpty());
871 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.DirectUnionLeaf(\"128\".toCharArray())",
874 final Module module = resolveModule("test-type-provider");
875 final QName leafUnionNode = QName.create(module.getQNameModule(), "root-union-leaf");
876 DataSchemaNode rootNode = module.getDataChildByName(leafUnionNode);
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 final QName leafBitsNode = QName.create(module.getQNameModule(), "root-bits-leaf");
894 rootNode = module.getDataChildByName(leafBitsNode);
895 assertNotNull("leaf bits-leaf is not present in root of module "+ module.getName(), rootNode);
896 assertTrue(rootNode instanceof LeafSchemaNode);
897 leaf = (LeafSchemaNode) rootNode;
898 result = provider.getTypeDefaultConstruction(leaf);
899 assertNotNull(result);
900 assertTrue(!result.isEmpty());
901 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootBitsLeaf(true, false, false)",
904 leaf = provideLeafForGetDefaultConstructionTestCase("yang-bits");
905 result = provider.getTypeDefaultConstruction(leaf, "only-10-Mb");
906 assertNotNull(result);
907 assertTrue(!result.isEmpty());
908 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBits(false, false, true)",
911 leaf = provideLeafForGetDefaultConstructionTestCase("bar-id");
912 result = provider.getTypeDefaultConstruction(leaf, "128");
913 assertNotNull(result);
914 assertTrue(!result.isEmpty());
915 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"128\"))",
918 leaf = provideLeafForGetDefaultConstructionTestCase("foo-leafref-value");
919 result = provider.getTypeDefaultConstruction(leaf, "32");
920 assertNotNull(result);
921 assertTrue(!result.isEmpty());
922 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"32\"))",
925 leaf = provideLeafForGetDefaultConstructionTestCase("foo-cond-bar-item");
926 result = provider.getTypeDefaultConstruction(leaf, "10");
927 assertNotNull(result);
928 assertTrue(!result.isEmpty());
929 assertEquals("new java.lang.Object()",