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
8 package org.opendaylight.mdsal.binding.yang.types;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertTrue;
13 import static org.mockito.Mockito.doReturn;
15 import com.google.common.collect.Range;
16 import java.util.List;
17 import java.util.Optional;
19 import org.junit.AfterClass;
20 import org.junit.BeforeClass;
21 import org.junit.Ignore;
22 import org.junit.Test;
23 import org.junit.runner.RunWith;
24 import org.mockito.Mock;
25 import org.mockito.junit.MockitoJUnitRunner;
26 import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
27 import org.opendaylight.mdsal.binding.model.api.ConcreteType;
28 import org.opendaylight.mdsal.binding.model.api.Enumeration;
29 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
30 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
31 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
32 import org.opendaylight.mdsal.binding.model.api.Restrictions;
33 import org.opendaylight.mdsal.binding.model.api.Type;
34 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
35 import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
36 import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl;
37 import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
38 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
39 import org.opendaylight.yangtools.yang.common.QName;
40 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
41 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.Module;
45 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
46 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
47 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
48 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
49 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
50 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
51 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
54 * Test suite for testing public methods in TypeProviderImpl class.
56 * @see org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider
57 * @author Lukas Sedlak <lsedlak@cisco.com>
59 @RunWith(MockitoJUnitRunner.class)
60 public class TypeProviderTest {
62 private static SchemaContext SCHEMA_CONTEXT;
63 private static Module TEST_TYPE_PROVIDER;
66 private SchemaPath schemaPath;
69 private SchemaNode schemaNode;
72 public static void beforeClass() {
73 SCHEMA_CONTEXT = TypeProviderModel.createTestContext();
74 TEST_TYPE_PROVIDER = resolveModule(TypeProviderModel.TEST_TYPE_PROVIDER_MODULE_NAME);
78 public static void afterClass() {
79 TEST_TYPE_PROVIDER = null;
80 SCHEMA_CONTEXT = null;
83 private static Module resolveModule(final String moduleName) {
84 return SCHEMA_CONTEXT.findModules(moduleName).iterator().next();
87 @Test(expected = IllegalArgumentException.class)
88 public void typeProviderInstanceWithNullSchemaContextTest() {
89 new RuntimeTypeProvider(null);
92 @Test(expected = IllegalArgumentException.class)
93 public void putReferencedTypeWithNullSchemaPathParamTest() {
94 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
96 provider.putReferencedType(null, null);
97 provider.putReferencedType(this.schemaPath, null);
100 @Test(expected = IllegalArgumentException.class)
101 public void putReferencedTypeWithNullRefTypeParamTest() {
102 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
104 provider.putReferencedType(this.schemaPath, null);
108 public void getAdditionalTypesTest() {
109 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
111 assertNotNull(provider.getAdditionalTypes());
114 @Test(expected = IllegalArgumentException.class)
115 public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
116 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
118 provider.javaTypeForSchemaDefinitionType(null, null, null);
121 @Test(expected = IllegalArgumentException.class)
122 public void javaTypeForSchemaDefinitionTypeTypedefNullQNameTest() {
123 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
125 final TestIntegerTypeDefinition testTypedef = new TestIntegerTypeDefinition();
126 provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
129 private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName,
130 final String leafNodeName) {
131 final QName containerNode = QName.create(module.getQNameModule(), containerName);
132 final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get();
133 assertTrue(rootNode instanceof DataNodeContainer);
135 final QName leafNode = QName.create(module.getQNameModule(), leafNodeName);
136 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
137 final DataSchemaNode node = rootContainer.findDataChildByName(leafNode).get();
138 assertTrue(node instanceof LeafSchemaNode);
139 return (LeafSchemaNode) node;
142 private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module,
143 final String containerName, final String leafListNodeName) {
144 final QName containerNode = QName.create(module.getQNameModule(), containerName);
145 final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get();
146 assertTrue(rootNode instanceof DataNodeContainer);
148 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
149 final QName leafListNode = QName.create(module.getQNameModule(), leafListNodeName);
150 final DataSchemaNode node = rootContainer.findDataChildByName(leafListNode).get();
151 assertTrue(node instanceof LeafListSchemaNode);
152 return (LeafListSchemaNode) node;
156 public void javaTypeForSchemaDefinitionExtTypeTest() {
157 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
158 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
161 final TypeDefinition<?> leafType = leaf.getType();
162 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
163 assertNotNull(result);
164 assertTrue(result instanceof GeneratedTransferObject);
166 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
167 assertEquals("base-yang-types", genTO.getModuleName());
168 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
169 genTO.getPackageName());
170 assertEquals("YangInt8", genTO.getName());
171 assertEquals(1, genTO.getProperties().size());
175 public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
176 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
177 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
178 "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",
189 genTO.getPackageName());
190 assertEquals("YangInt8Restricted", genTO.getName());
191 assertEquals(1, genTO.getProperties().size());
192 final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
194 assertTrue(rangeConstraints.isPresent());
195 final Range<?> constraint = rangeConstraints.get().getAllowedRanges().asRanges().iterator().next();
196 assertEquals((byte) 1, constraint.lowerEndpoint());
197 assertEquals((byte) 100, constraint.upperEndpoint());
201 public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
202 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
204 final Module testTypeProvider = resolveModule("test-type-provider");
205 final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider,
206 "empty-pattern-string");
208 assertNotNull(emptyPatternString);
209 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
211 Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
212 assertNotNull(result);
213 assertTrue(result instanceof GeneratedTransferObject);
215 result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
216 assertNotNull(result);
217 assertTrue(result instanceof GeneratedTransferObject);
220 private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
221 TypeDefinition<?> result = null;
222 final Set<TypeDefinition<?>> typeDefs = module.getTypeDefinitions();
223 for (final TypeDefinition<?> typedef : typeDefs) {
224 if (typedef.getQName().getLocalName().equals(typedefName)) {
231 // 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 CodegenTypeProvider(SCHEMA_CONTEXT);
236 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
237 "bug-1862-restricted-typedef");
239 final TypeDefinition<?> leafType = leaf.getType();
240 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
241 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
242 assertNotNull(result);
243 assertTrue(result instanceof GeneratedTransferObject);
244 //TODO: complete test after bug 1862 is fixed
248 public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
249 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
250 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-enum-leaf");
251 TypeDefinition<?> leafType = leaf.getType();
252 Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
253 assertNotNull(result);
254 assertTrue(result instanceof Enumeration);
256 final Enumeration enumType = (Enumeration) result;
257 final List<Enumeration.Pair> enumValues = enumType.getValues();
258 assertTrue(!enumValues.isEmpty());
259 assertEquals("a", enumValues.get(0).getName());
260 assertEquals("b", enumValues.get(1).getName());
261 assertEquals("A", enumValues.get(0).getMappedName());
262 assertEquals("B", enumValues.get(1).getMappedName());
264 leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-direct-use-of-enum");
265 leafType = leaf.getType();
266 result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
267 assertNotNull(result);
268 assertTrue(result instanceof ConcreteType);
270 assertEquals("java.lang", result.getPackageName());
271 assertEquals("Enum", result.getName());
275 public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
276 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
277 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar", "leafref-value");
278 TypeDefinition<?> leafType = leaf.getType();
279 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
280 assertNotNull(leafrefResolvedType1);
281 assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
283 final Module module = resolveModule("test-type-provider-b");
284 final QName leafNode = QName.create(module.getQNameModule(), "id");
285 final DataSchemaNode rootNode = module.findDataChildByName(leafNode).get();
286 assertNotNull("leaf id is not present in root of module " + module.getName(), rootNode);
287 assertTrue(rootNode instanceof LeafSchemaNode);
288 leaf = (LeafSchemaNode) rootNode;
289 leafType = leaf.getType();
291 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
292 assertNotNull(leafrefResolvedType2);
293 assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
297 public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
298 final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
300 setReferencedTypeForTypeProvider(provider);
302 final Module module = resolveModule("test-type-provider-b");
304 final QName leafNode = QName.create(module.getQNameModule(), "enum");
305 final DataSchemaNode enumNode = module.findDataChildByName(leafNode).get();
306 assertTrue(enumNode instanceof LeafSchemaNode);
307 final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
308 final TypeDefinition<?> leafType = leaf.getType();
310 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
311 assertNotNull(leafrefResolvedType1);
312 assertTrue(leafrefResolvedType1 instanceof ReferencedTypeImpl);
314 final QName leafListNode = QName.create(module.getQNameModule(), "enums");
315 final DataSchemaNode enumListNode = module.findDataChildByName(leafListNode).get();
316 assertTrue(enumListNode instanceof LeafListSchemaNode);
317 final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
318 final TypeDefinition<?> leafListType = leafList.getType();
320 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
321 assertNotNull(leafrefResolvedType2);
322 assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
325 private static void setReferencedTypeForTypeProvider(final AbstractTypeProvider provider) {
326 final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
327 "resolve-direct-use-of-enum");
328 final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
329 Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
331 Type refType = new ReferencedTypeImpl(enumType.getIdentifier());
332 provider.putReferencedType(enumLeafNode.getPath(), refType);
334 final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(TEST_TYPE_PROVIDER,
335 "foo", "list-of-enums");
336 final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
337 enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
339 refType = new ReferencedTypeImpl(enumType.getIdentifier());
340 provider.putReferencedType(enumListNode.getPath(), refType);
344 public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
345 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
346 final Module module = resolveModule("test-type-provider-b");
348 final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
349 final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
350 assertTrue(condLeaf instanceof LeafSchemaNode);
351 final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
352 final TypeDefinition<?> leafType = leaf.getType();
354 final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
355 assertNotNull(resultType);
356 assertTrue(resultType instanceof ConcreteType);
357 assertEquals("java.lang", resultType.getPackageName());
358 assertEquals("Object", resultType.getName());
361 @Test(expected = IllegalArgumentException.class)
362 public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
363 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
364 final Module module = resolveModule("test-type-provider-b");
366 final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
367 final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
368 assertTrue(condLeaf instanceof LeafSchemaNode);
369 final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
370 final TypeDefinition<?> leafType = leaf.getType();
372 provider.javaTypeForSchemaDefinitionType(leafType, leaf);
375 @Test(expected = IllegalArgumentException.class)
376 public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
377 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
379 provider.provideTypeForLeafref(null, null, false);
382 @Test(expected = IllegalArgumentException.class)
383 public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
384 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
386 final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
387 provider.provideTypeForLeafref(leafrePath, this.schemaNode, false);
390 @Test(expected = NullPointerException.class)
391 public void provideTypeForLeafrefWithNullParentModuleTest() {
392 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
393 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar",
395 final TypeDefinition<?> leafType = leaf.getType();
396 assertTrue(leafType instanceof LeafrefTypeDefinition);
397 doReturn(null).when(this.schemaNode).getPath();
398 provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, this.schemaNode, false);
402 public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
403 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
404 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "crypto");
405 final TypeDefinition<?> leafType = leaf.getType();
407 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
408 assertNotNull(result);
409 assertTrue(result instanceof ParameterizedType);
413 public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
414 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
415 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
416 "simple-int-types-union");
417 final TypeDefinition<?> leafType = leaf.getType();
419 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
420 assertNotNull(result);
421 assertTrue(result instanceof GeneratedTransferObject);
422 assertEquals("YangUnion", result.getName());
423 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
427 public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
428 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
429 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
431 final TypeDefinition<?> leafType = leaf.getType();
433 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
434 assertNotNull(result);
435 assertTrue(result instanceof GeneratedTransferObject);
436 assertEquals("ComplexUnion", result.getName());
437 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
441 public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
442 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
443 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
444 "complex-string-int-union");
445 final TypeDefinition<?> leafType = leaf.getType();
447 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
448 assertNotNull(result);
449 assertTrue(result instanceof GeneratedTransferObject);
450 assertEquals("ComplexStringIntUnion", result.getName());
451 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
455 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
456 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
458 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER, "complex-union");
460 assertNotNull(unionTypeDef);
461 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
462 GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
463 JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
464 (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
466 assertNotNull(unionTypeBuilder);
468 GeneratedTransferObject unionType = unionTypeBuilder.build();
469 assertEquals("ComplexUnion", unionType.getName());
473 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
474 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
476 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER,
477 "complex-string-int-union");
479 assertNotNull(unionTypeDef);
480 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
481 final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
482 JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
483 (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
485 assertNotNull(unionTypeBuilder);
487 final GeneratedTransferObject unionType = unionTypeBuilder.build();
488 assertEquals("ComplexStringIntUnion", unionType.getName());
492 public void generatedTypeForExtendedDefinitionTypeTest() {
493 final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
495 final Module baseYangTypes = resolveModule("base-yang-types");
496 final Set<TypeDefinition<?>> typeDefs = baseYangTypes.getTypeDefinitions();
498 Type yangBoolean = null;
499 Type yangEmpty = null;
500 Type yangEnumeration = null;
501 Type yangInt8 = null;
502 Type yangInt8Restricted = null;
503 Type yangInt16 = null;
504 Type yangInt32 = null;
505 Type yangInt64 = null;
506 Type yangString = null;
507 Type yangDecimal = null;
508 Type yangUint8 = null;
509 Type yangUint16 = null;
510 Type yangUint32 = null;
511 Type yangUint64 = null;
512 Type yangUnion = null;
513 Type yangBinary = null;
514 Type yangBits = null;
515 Type yangInstanceIdentifier = null;
517 for (final TypeDefinition<?> typedef : typeDefs) {
518 final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
519 if (type instanceof GeneratedTransferObject) {
520 if (type.getName().equals("YangBoolean")) {
522 } else if (type.getName().equals("YangEmpty")) {
524 } else if (type.getName().equals("YangInt8")) {
526 } else if (type.getName().equals("YangInt8Restricted")) {
527 yangInt8Restricted = type;
528 } else if (type.getName().equals("YangInt16")) {
530 } else if (type.getName().equals("YangInt32")) {
532 } else if (type.getName().equals("YangInt64")) {
534 } else if (type.getName().equals("YangString")) {
536 } else if (type.getName().equals("YangDecimal64")) {
538 } else if (type.getName().equals("YangUint8")) {
540 } else if (type.getName().equals("YangUint16")) {
542 } else if (type.getName().equals("YangUint32")) {
544 } else if (type.getName().equals("YangUint64")) {
546 } else if (type.getName().equals("YangUnion")) {
548 } else if (type.getName().equals("YangBinary")) {
550 } else if (type.getName().equals("YangInstanceIdentifier")) {
551 yangInstanceIdentifier = type;
552 } else if (type.getName().equals("YangBits")) {
555 } else if (type instanceof Enumeration) {
556 if (type.getName().equals("YangEnumeration")) {
557 yangEnumeration = type;
562 assertNotNull(yangBoolean);
563 assertNotNull(yangEmpty);
564 assertNotNull(yangEnumeration);
565 assertNotNull(yangInt8);
566 assertNotNull(yangInt8Restricted);
567 assertNotNull(yangInt16);
568 assertNotNull(yangInt32);
569 assertNotNull(yangInt64);
570 assertNotNull(yangString);
571 assertNotNull(yangDecimal);
572 assertNotNull(yangUint8);
573 assertNotNull(yangUint16);
574 assertNotNull(yangUint32);
575 assertNotNull(yangUint64);
576 assertNotNull(yangUnion);
577 assertNotNull(yangBinary);
578 assertNotNull(yangBits);
579 assertNotNull(yangInstanceIdentifier);
582 @Test(expected = IllegalArgumentException.class)
583 public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
584 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
585 provider.generatedTypeForExtendedDefinitionType(null, null);
588 @Test(expected = IllegalArgumentException.class)
589 public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
590 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
591 final TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
592 provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
596 public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
597 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
599 final Module baseYangTypes = resolveModule("test-type-provider");
600 final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes,
601 "extended-yang-int8");
602 assertNotNull(extYangInt8Typedef);
603 final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
604 assertNotNull(extType);
605 assertTrue(extType instanceof GeneratedTransferObject);
609 public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
610 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
612 final Module baseYangTypes = resolveModule("test-type-provider");
613 final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes,
614 "bar-item-leafref-id");
615 assertNotNull(barItemLeafrefId);
616 final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
617 assertEquals(null, extType);
621 public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
622 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
624 final Module baseYangTypes = resolveModule("test-type-provider");
626 final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes,
627 "aes-identityref-type");
629 assertNotNull(aesIdentityrefType);
630 final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
631 assertEquals(null, extType);
634 @Test(expected = NullPointerException.class)
635 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
636 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
637 provider.provideGeneratedTOBuilderForBitsTypeDefinition(JavaTypeName.create("foo", "foo"), null, "foo");
641 public void getConstructorPropertyNameTest() {
642 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
644 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
646 final TypeDefinition<?> leafType = leaf.getType();
648 final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
649 assertEquals("value", ctorPropertyName);
651 final String emptyStringName = provider.getConstructorPropertyName(leaf);
652 assertTrue(emptyStringName.isEmpty());
656 public void getParamNameFromTypeTest() {
657 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
659 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
661 final TypeDefinition<?> leafType = leaf.getType();
663 final String paramName = provider.getParamNameFromType(leafType);
664 assertEquals("yangInt8", paramName);
668 public void addUnitsToGenTOTest() {
669 final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(
670 JavaTypeName.create("test.package", "TestBuilder"));
672 CodegenTypeProvider.addUnitsToGenTO(builder, null);
673 GeneratedTransferObject genTO = builder.build();
674 assertTrue(genTO.getConstantDefinitions().isEmpty());
676 CodegenTypeProvider.addUnitsToGenTO(builder, "");
677 genTO = builder.build();
678 assertTrue(genTO.getConstantDefinitions().isEmpty());
680 CodegenTypeProvider.addUnitsToGenTO(builder, "125");
681 genTO = builder.build();
682 assertTrue(!genTO.getConstantDefinitions().isEmpty());
683 assertEquals(1, genTO.getConstantDefinitions().size());
684 assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
685 assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
688 @Test(expected = NullPointerException.class)
689 public void getTypeDefaultConstructionLeafTypeNullTest() {
690 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
691 final TestLeafSchemaNode leafSchemaNode = new TestLeafSchemaNode();
692 provider.getTypeDefaultConstruction(leafSchemaNode, null);
695 @Test(expected = NullPointerException.class)
696 public void getTypeDefaultConstructionDefaultValueNullTest() {
697 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
698 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
699 provider.getTypeDefaultConstruction(leaf, null);
702 private static LeafSchemaNode provideLeafForGetDefaultConstructionTestCase(final String leafName) {
703 return provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "construction-type-test", leafName);
706 @Test(expected = UnsupportedOperationException.class)
707 public void getTypeDefaultConstructionDefaultValueForInstanceIdentifierTest() {
708 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
709 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("foo-container-id");
710 provider.getTypeDefaultConstruction(leaf, "NAN");
713 @Test(expected = UnsupportedOperationException.class)
714 public void getTypeDefaultConstructionDefaultValueForIdentityrefTest() {
715 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
716 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("aes-identityref-type");
717 provider.getTypeDefaultConstruction(leaf, "NAN");
721 public void getTypeDefaultConstructionDefaultValueTest() {
722 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
724 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
725 String result = provider.getTypeDefaultConstruction(leaf, "true");
726 assertNotNull(result);
727 assertTrue(!result.isEmpty());
728 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
729 + "YangBoolean(java.lang.Boolean.TRUE)", result);
731 leaf = provideLeafForGetDefaultConstructionTestCase("yang-empty");
732 result = provider.getTypeDefaultConstruction(leaf, "true");
733 assertNotNull(result);
734 assertTrue(!result.isEmpty());
735 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
736 + "YangEmpty(java.lang.Boolean.TRUE)", result);
738 leaf = provideLeafForGetDefaultConstructionTestCase("yang-enumeration");
739 result = provider.getTypeDefaultConstruction(leaf, "a");
740 assertNotNull(result);
741 assertTrue(!result.isEmpty());
742 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
743 + "YangEnumeration.A", result);
745 leaf = provideLeafForGetDefaultConstructionTestCase("direct-use-of-enum");
746 result = provider.getTypeDefaultConstruction(leaf, "y");
747 assertNotNull(result);
748 assertTrue(!result.isEmpty());
749 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912."
750 + "construction.type.test.DirectUseOfEnum.Y", result);
752 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8");
753 result = provider.getTypeDefaultConstruction(leaf, "17");
754 assertNotNull(result);
755 assertTrue(!result.isEmpty());
756 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
757 + "YangInt8(java.lang.Byte.valueOf(\"17\"))", result);
759 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8-restricted");
760 result = provider.getTypeDefaultConstruction(leaf, "99");
761 assertNotNull(result);
762 assertTrue(!result.isEmpty());
763 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
764 + "YangInt8Restricted(java.lang.Byte.valueOf(\"99\"))", result);
766 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int16");
767 result = provider.getTypeDefaultConstruction(leaf, "1024");
768 assertNotNull(result);
769 assertTrue(!result.isEmpty());
770 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
771 + "YangInt16(java.lang.Short.valueOf(\"1024\"))", result);
773 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int32");
774 result = provider.getTypeDefaultConstruction(leaf, "1048576");
775 assertNotNull(result);
776 assertTrue(!result.isEmpty());
777 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
778 + "YangInt32(java.lang.Integer.valueOf(\"1048576\"))", result);
780 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int64");
781 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
782 assertNotNull(result);
783 assertTrue(!result.isEmpty());
784 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
785 + "YangInt64(java.lang.Long.valueOf(\"1099511627776\"))", result);
787 leaf = provideLeafForGetDefaultConstructionTestCase("yang-string");
788 result = provider.getTypeDefaultConstruction(leaf, "TEST");
789 assertNotNull(result);
790 assertTrue(!result.isEmpty());
791 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
792 + "YangString(\"TEST\")", result);
794 leaf = provideLeafForGetDefaultConstructionTestCase("yang-decimal64");
795 result = provider.getTypeDefaultConstruction(leaf, "1274.25");
796 assertNotNull(result);
797 assertTrue(!result.isEmpty());
798 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
799 + "YangDecimal64(new java.math.BigDecimal(\"1274.25\"))", result);
801 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint8");
802 result = provider.getTypeDefaultConstruction(leaf, "128");
803 assertNotNull(result);
804 assertTrue(!result.isEmpty());
805 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
806 + "YangUint8(java.lang.Short.valueOf(\"128\"))", result);
808 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint16");
809 result = provider.getTypeDefaultConstruction(leaf, "1048576");
810 assertNotNull(result);
811 assertTrue(!result.isEmpty());
812 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
813 + "YangUint16(java.lang.Integer.valueOf(\"1048576\"))", result);
815 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint32");
816 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
817 assertNotNull(result);
818 assertTrue(!result.isEmpty());
819 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
820 + "YangUint32(java.lang.Long.valueOf(\"1099511627776\"))", result);
822 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint64");
823 result = provider.getTypeDefaultConstruction(leaf, "1208925819614629174706176");
824 assertNotNull(result);
825 assertTrue(!result.isEmpty());
826 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
827 + "YangUint64(new java.math.BigInteger(\"1208925819614629174706176\"))", result);
829 //FIXME: Is this correct scenario and correct result?
830 leaf = provideLeafForGetDefaultConstructionTestCase("complex-union");
831 result = provider.getTypeDefaultConstruction(leaf, "75");
832 assertNotNull(result);
833 assertTrue(!result.isEmpty());
834 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912."
835 + "ComplexUnion(\"null\".toCharArray())", result);
837 //FIXME: Is this correct scenario and correct result?
838 leaf = provideLeafForGetDefaultConstructionTestCase("complex-string-int-union");
839 result = provider.getTypeDefaultConstruction(leaf, "TEST_UNION_STRING_DEFAULT");
840 assertNotNull(result);
841 assertTrue(!result.isEmpty());
842 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912."
843 + "ComplexStringIntUnion(\"null\".toCharArray())", result);
845 leaf = provideLeafForGetDefaultConstructionTestCase("simple-int-types-union");
846 result = provider.getTypeDefaultConstruction(leaf, "2048");
847 assertNotNull(result);
848 assertTrue(!result.isEmpty());
849 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
850 + "YangUnion(\"null\".toCharArray())", result);
853 leaf = provideLeafForGetDefaultConstructionTestCase("direct-union-leaf");
854 result = provider.getTypeDefaultConstruction(leaf);
855 assertNotNull(result);
856 assertTrue(!result.isEmpty());
857 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912."
858 + "DirectUnionLeaf(\"128\".toCharArray())", result);
860 final Module module = resolveModule("test-type-provider");
861 final QName leafUnionNode = QName.create(module.getQNameModule(), "root-union-leaf");
862 DataSchemaNode rootNode = module.findDataChildByName(leafUnionNode).get();
863 assertTrue(rootNode instanceof LeafSchemaNode);
864 leaf = (LeafSchemaNode) rootNode;
865 result = provider.getTypeDefaultConstruction(leaf);
866 assertNotNull(result);
867 assertTrue(!result.isEmpty());
868 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912."
869 + "TestTypeProviderData.RootUnionLeaf(\"256\".toCharArray())", result);
871 leaf = provideLeafForGetDefaultConstructionTestCase("yang-binary");
872 result = provider.getTypeDefaultConstruction(leaf, "0xffffff");
873 assertNotNull(result);
874 assertTrue(!result.isEmpty());
875 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
876 + "YangBinary(new byte[] {-45, 23, -33, 125, -9, -33})", result);
878 final QName leafBitsNode = QName.create(module.getQNameModule(), "root-bits-leaf");
879 rootNode = module.findDataChildByName(leafBitsNode).get();
880 assertTrue(rootNode instanceof LeafSchemaNode);
881 leaf = (LeafSchemaNode) rootNode;
882 result = provider.getTypeDefaultConstruction(leaf);
883 assertNotNull(result);
884 assertTrue(!result.isEmpty());
885 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912."
886 + "TestTypeProviderData.RootBitsLeaf(true, false, false)", result);
888 leaf = provideLeafForGetDefaultConstructionTestCase("yang-bits");
889 result = provider.getTypeDefaultConstruction(leaf, "only-10-Mb");
890 assertNotNull(result);
891 assertTrue(!result.isEmpty());
892 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
893 + "YangBits(false, false, true)", result);
895 leaf = provideLeafForGetDefaultConstructionTestCase("bar-id");
896 result = provider.getTypeDefaultConstruction(leaf, "128");
897 assertNotNull(result);
898 assertTrue(!result.isEmpty());
899 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
900 + "YangInt16(java.lang.Short.valueOf(\"128\"))", result);
902 leaf = provideLeafForGetDefaultConstructionTestCase("foo-leafref-value");
903 result = provider.getTypeDefaultConstruction(leaf, "32");
904 assertNotNull(result);
905 assertTrue(!result.isEmpty());
906 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914."
907 + "YangInt8(java.lang.Byte.valueOf(\"32\"))", result);
909 leaf = provideLeafForGetDefaultConstructionTestCase("foo-cond-bar-item");
910 result = provider.getTypeDefaultConstruction(leaf, "10");
911 assertNotNull(result);
912 assertTrue(!result.isEmpty());
913 assertEquals("new java.lang.Object()", result);