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.runners.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.TypeProviderImpl
58 * @author Lukas Sedlak <lsedlak@cisco.com>
60 @RunWith(MockitoJUnitRunner.class)
61 public class TypeProviderTest {
63 private static SchemaContext SCHEMA_CONTEXT;
64 private static Module TEST_TYPE_PROVIDER;
67 private SchemaPath schemaPath;
70 private SchemaNode schemaNode;
73 public static void beforeClass() {
74 SCHEMA_CONTEXT = TypeProviderModel.createTestContext();
75 TEST_TYPE_PROVIDER = resolveModule(TypeProviderModel.TEST_TYPE_PROVIDER_MODULE_NAME);
79 public static void afterClass() {
80 TEST_TYPE_PROVIDER = null;
81 SCHEMA_CONTEXT = null;
84 private static Module resolveModule(final String moduleName) {
85 return SCHEMA_CONTEXT.findModules(moduleName).iterator().next();
88 @Test(expected = IllegalArgumentException.class)
89 public void typeProviderInstanceWithNullSchemaContextTest() {
90 new RuntimeTypeProvider(null);
93 @Test(expected = IllegalArgumentException.class)
94 public void putReferencedTypeWithNullSchemaPathParamTest() {
95 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
97 provider.putReferencedType(null, null);
98 provider.putReferencedType(this.schemaPath, null);
101 @Test(expected = IllegalArgumentException.class)
102 public void putReferencedTypeWithNullRefTypeParamTest() {
103 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
105 provider.putReferencedType(this.schemaPath, null);
109 public void getAdditionalTypesTest() {
110 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
112 assertNotNull(provider.getAdditionalTypes());
115 @Test(expected = IllegalArgumentException.class)
116 public void javaTypeForSchemaDefinitionTypeNullTypedefTest() {
117 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
119 provider.javaTypeForSchemaDefinitionType(null, null, null);
122 @Test(expected = IllegalArgumentException.class)
123 public void javaTypeForSchemaDefinitionTypeTypedefNullQNameTest() {
124 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
126 final TestIntegerTypeDefinition testTypedef = new TestIntegerTypeDefinition();
127 provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
130 private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName,
131 final String leafNodeName) {
132 final QName containerNode = QName.create(module.getQNameModule(), containerName);
133 final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
134 assertNotNull("Container foo is not present in root of module " + module.getName(), rootNode);
135 assertTrue(rootNode instanceof DataNodeContainer);
137 final QName leafNode = QName.create(module.getQNameModule(), leafNodeName);
138 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
139 final DataSchemaNode node = rootContainer.getDataChildByName(leafNode);
141 assertTrue(node instanceof LeafSchemaNode);
142 return (LeafSchemaNode) node;
145 private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module,
146 final String containerName, final String leafListNodeName) {
147 final QName containerNode = QName.create(module.getQNameModule(), containerName);
148 final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
149 assertNotNull("Container foo is not present in root of module " + module.getName(), rootNode);
150 assertTrue(rootNode instanceof DataNodeContainer);
152 final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
153 final QName leafListNode = QName.create(module.getQNameModule(), leafListNodeName);
154 final DataSchemaNode node = rootContainer.getDataChildByName(leafListNode);
156 assertTrue(node instanceof LeafListSchemaNode);
157 return (LeafListSchemaNode) node;
161 public void javaTypeForSchemaDefinitionExtTypeTest() {
162 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
163 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
166 final TypeDefinition<?> leafType = leaf.getType();
167 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
168 assertNotNull(result);
169 assertTrue(result instanceof GeneratedTransferObject);
171 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
172 assertEquals("base-yang-types", genTO.getModuleName());
173 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
174 genTO.getPackageName());
175 assertEquals("YangInt8", genTO.getName());
176 assertEquals(1, genTO.getProperties().size());
180 public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
181 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
182 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
183 "restricted-int8-type");
185 final TypeDefinition<?> leafType = leaf.getType();
186 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
188 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
189 assertNotNull(result);
190 assertTrue(result instanceof GeneratedTransferObject);
192 final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
193 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
194 genTO.getPackageName());
195 assertEquals("YangInt8Restricted", genTO.getName());
196 assertEquals(1, genTO.getProperties().size());
197 final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
199 assertTrue(rangeConstraints.isPresent());
200 final Range<?> constraint = rangeConstraints.get().getAllowedRanges().asRanges().iterator().next();
201 assertEquals((byte) 1, constraint.lowerEndpoint());
202 assertEquals((byte) 100, constraint.upperEndpoint());
206 public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
207 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
209 final Module testTypeProvider = resolveModule("test-type-provider");
210 final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider,
211 "empty-pattern-string");
213 assertNotNull(emptyPatternString);
214 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
216 Type result = provider.javaTypeForSchemaDefinitionType(emptyPatternString, emptyPatternString, restrictions);
217 assertNotNull(result);
218 assertTrue(result instanceof GeneratedTransferObject);
220 result = provider.generatedTypeForExtendedDefinitionType(emptyPatternString, emptyPatternString);
221 assertNotNull(result);
222 assertTrue(result instanceof GeneratedTransferObject);
225 private static TypeDefinition<?> resolveTypeDefinitionFromModule(final Module module, final String typedefName) {
226 TypeDefinition<?> result = null;
227 final Set<TypeDefinition<?>> typeDefs = module.getTypeDefinitions();
228 for (final TypeDefinition<?> typedef : typeDefs) {
229 if (typedef.getQName().getLocalName().equals(typedefName)) {
237 * FIXME: Remove @Ignore annotation once the bug https://bugs.opendaylight.org/show_bug.cgi?id=1862 is fixed
241 public void bug1862RestrictedTypedefTransformationTest() {
242 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
243 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
244 "bug-1862-restricted-typedef");
246 final TypeDefinition<?> leafType = leaf.getType();
247 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
248 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
249 assertNotNull(result);
250 assertTrue(result instanceof GeneratedTransferObject);
251 //TODO: complete test after bug 1862 is fixed
255 public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
256 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
257 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-enum-leaf");
258 TypeDefinition<?> leafType = leaf.getType();
259 Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
260 assertNotNull(result);
261 assertTrue(result instanceof Enumeration);
263 final Enumeration enumType = (Enumeration) result;
264 final List<Enumeration.Pair> enumValues = enumType.getValues();
265 assertTrue(!enumValues.isEmpty());
266 assertEquals("a", enumValues.get(0).getName());
267 assertEquals("b", enumValues.get(1).getName());
268 assertEquals("A", enumValues.get(0).getMappedName());
269 assertEquals("B", enumValues.get(1).getMappedName());
271 leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-direct-use-of-enum");
272 leafType = leaf.getType();
273 result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
274 assertNotNull(result);
275 assertTrue(result instanceof ConcreteType);
277 assertEquals("java.lang", result.getPackageName());
278 assertEquals("Enum", result.getName());
282 public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
283 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
284 LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar", "leafref-value");
285 TypeDefinition<?> leafType = leaf.getType();
286 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
287 assertNotNull(leafrefResolvedType1);
288 assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
290 final Module module = resolveModule("test-type-provider-b");
291 final QName leafNode = QName.create(module.getQNameModule(), "id");
292 final DataSchemaNode rootNode = module.getDataChildByName(leafNode);
293 assertNotNull("leaf id is not present in root of module " + module.getName(), rootNode);
294 assertTrue(rootNode instanceof LeafSchemaNode);
295 leaf = (LeafSchemaNode) rootNode;
296 leafType = leaf.getType();
298 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
299 assertNotNull(leafrefResolvedType2);
300 assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
304 public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
305 final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
307 setReferencedTypeForTypeProvider(provider);
309 final Module module = resolveModule("test-type-provider-b");
311 final QName leafNode = QName.create(module.getQNameModule(), "enum");
312 final DataSchemaNode enumNode = module.getDataChildByName(leafNode);
313 assertNotNull("leaf enum is not present in root of module " + module.getName(), enumNode);
314 assertTrue(enumNode instanceof LeafSchemaNode);
315 final LeafSchemaNode leaf = (LeafSchemaNode) enumNode;
316 final TypeDefinition<?> leafType = leaf.getType();
318 final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
319 assertNotNull(leafrefResolvedType1);
320 assertTrue(leafrefResolvedType1 instanceof ReferencedTypeImpl);
322 final QName leafListNode = QName.create(module.getQNameModule(), "enums");
323 final DataSchemaNode enumListNode = module.getDataChildByName(leafListNode);
324 assertNotNull("leaf-list enums is not present in root of module " + module.getName(), enumNode);
325 assertTrue(enumListNode instanceof LeafListSchemaNode);
326 final LeafListSchemaNode leafList = (LeafListSchemaNode) enumListNode;
327 final TypeDefinition<?> leafListType = leafList.getType();
329 final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafListType, leafList);
330 assertNotNull(leafrefResolvedType2);
331 assertTrue(leafrefResolvedType2 instanceof ParameterizedType);
334 private static void setReferencedTypeForTypeProvider(final AbstractTypeProvider provider) {
335 final LeafSchemaNode enumLeafNode = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
336 "resolve-direct-use-of-enum");
337 final TypeDefinition<?> enumLeafTypedef = enumLeafNode.getType();
338 Type enumType = provider.javaTypeForSchemaDefinitionType(enumLeafTypedef, enumLeafNode);
340 Type refType = new ReferencedTypeImpl(enumType.getIdentifier());
341 provider.putReferencedType(enumLeafNode.getPath(), refType);
343 final LeafListSchemaNode enumListNode = provideLeafListNodeFromTopLevelContainer(TEST_TYPE_PROVIDER,
344 "foo", "list-of-enums");
345 final TypeDefinition<?> enumLeafListTypedef = enumListNode.getType();
346 enumType = provider.javaTypeForSchemaDefinitionType(enumLeafListTypedef, enumListNode);
348 refType = new ReferencedTypeImpl(enumType.getIdentifier());
349 provider.putReferencedType(enumListNode.getPath(), refType);
353 public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
354 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
355 final Module module = resolveModule("test-type-provider-b");
357 final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
358 final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
359 assertNotNull("leaf conditional-leafref is not present in root of module " + module.getName(), condLeaf);
360 assertTrue(condLeaf instanceof LeafSchemaNode);
361 final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
362 final TypeDefinition<?> leafType = leaf.getType();
364 final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
365 assertNotNull(resultType);
366 assertTrue(resultType instanceof ConcreteType);
367 assertEquals("java.lang", resultType.getPackageName());
368 assertEquals("Object", resultType.getName());
371 @Test(expected = IllegalArgumentException.class)
372 public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
373 final TypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
374 final Module module = resolveModule("test-type-provider-b");
376 final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
377 final DataSchemaNode condLeaf = module.getDataChildByName(leafrefNode);
378 assertNotNull("leaf unreslovable-leafref is not present in root of module " + module.getName(), condLeaf);
379 assertTrue(condLeaf instanceof LeafSchemaNode);
380 final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
381 final TypeDefinition<?> leafType = leaf.getType();
383 provider.javaTypeForSchemaDefinitionType(leafType, leaf);
386 @Test(expected = IllegalArgumentException.class)
387 public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
388 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
390 provider.provideTypeForLeafref(null, null);
393 @Test(expected = IllegalArgumentException.class)
394 public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
395 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
397 final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
398 provider.provideTypeForLeafref(leafrePath, this.schemaNode);
401 @Test(expected = IllegalStateException.class)
402 public void provideTypeForLeafrefWithNullParentModuleTest() {
403 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
404 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar",
406 final TypeDefinition<?> leafType = leaf.getType();
407 assertTrue(leafType instanceof LeafrefTypeDefinition);
408 doReturn(null).when(this.schemaNode).getPath();
409 provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, this.schemaNode);
413 public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
414 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
415 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "crypto");
416 final TypeDefinition<?> leafType = leaf.getType();
418 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
419 assertNotNull(result);
420 assertTrue(result instanceof ParameterizedType);
424 public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
425 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
426 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
427 "simple-int-types-union");
428 final TypeDefinition<?> leafType = leaf.getType();
430 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
431 assertNotNull(result);
432 assertTrue(result instanceof GeneratedTransferObject);
433 assertEquals("YangUnion", result.getName());
434 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
438 public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
439 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
440 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
442 final TypeDefinition<?> leafType = leaf.getType();
444 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
445 assertNotNull(result);
446 assertTrue(result instanceof GeneratedTransferObject);
447 assertEquals("ComplexUnion", result.getName());
448 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
452 public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
453 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
454 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "use-of-unions",
455 "complex-string-int-union");
456 final TypeDefinition<?> leafType = leaf.getType();
458 final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
459 assertNotNull(result);
460 assertTrue(result instanceof GeneratedTransferObject);
461 assertEquals("ComplexStringIntUnion", result.getName());
462 //TODO: write additional asserts to compare whole GeneratedTrasnferObject against yang union definition
466 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
467 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
469 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER, "complex-union");
471 assertNotNull(unionTypeDef);
472 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
473 GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
474 JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
475 (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
477 assertNotNull(unionTypeBuilder);
479 GeneratedTransferObject unionType = unionTypeBuilder.build();
480 assertEquals("ComplexUnion", unionType.getName());
484 public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
485 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
487 final TypeDefinition<?> unionTypeDef = resolveTypeDefinitionFromModule(TEST_TYPE_PROVIDER,
488 "complex-string-int-union");
490 assertNotNull(unionTypeDef);
491 assertTrue(unionTypeDef.getBaseType() instanceof UnionTypeDefinition);
492 final GeneratedTOBuilder unionTypeBuilder = provider.provideGeneratedTOBuilderForUnionTypeDef(
493 JavaTypeName.create("test.package.name", BindingMapping.getClassName(unionTypeDef.getQName())),
494 (UnionTypeDefinition)unionTypeDef.getBaseType(), unionTypeDef);
496 assertNotNull(unionTypeBuilder);
498 final GeneratedTransferObject unionType = unionTypeBuilder.build();
499 assertEquals("ComplexStringIntUnion", unionType.getName());
503 public void generatedTypeForExtendedDefinitionTypeTest() {
504 final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
506 final Module baseYangTypes = resolveModule("base-yang-types");
507 final Set<TypeDefinition<?>> typeDefs = baseYangTypes.getTypeDefinitions();
509 Type yangBoolean = null;
510 Type yangEmpty = null;
511 Type yangEnumeration = null;
512 Type yangInt8 = null;
513 Type yangInt8Restricted = null;
514 Type yangInt16 = null;
515 Type yangInt32 = null;
516 Type yangInt64 = null;
517 Type yangString = null;
518 Type yangDecimal = null;
519 Type yangUint8 = null;
520 Type yangUint16 = null;
521 Type yangUint32 = null;
522 Type yangUint64 = null;
523 Type yangUnion = null;
524 Type yangBinary = null;
525 Type yangBits = null;
526 Type yangInstanceIdentifier = null;
528 for (final TypeDefinition<?> typedef : typeDefs) {
529 final Type type = provider.generatedTypeForExtendedDefinitionType(typedef, typedef);
530 if (type instanceof GeneratedTransferObject) {
531 if (type.getName().equals("YangBoolean")) {
533 } else if (type.getName().equals("YangEmpty")) {
535 } else if (type.getName().equals("YangInt8")) {
537 } else if (type.getName().equals("YangInt8Restricted")) {
538 yangInt8Restricted = type;
539 } else if (type.getName().equals("YangInt16")) {
541 } else if (type.getName().equals("YangInt32")) {
543 } else if (type.getName().equals("YangInt64")) {
545 } else if (type.getName().equals("YangString")) {
547 } else if (type.getName().equals("YangDecimal64")) {
549 } else if (type.getName().equals("YangUint8")) {
551 } else if (type.getName().equals("YangUint16")) {
553 } else if (type.getName().equals("YangUint32")) {
555 } else if (type.getName().equals("YangUint64")) {
557 } else if (type.getName().equals("YangUnion")) {
559 } else if (type.getName().equals("YangBinary")) {
561 } else if (type.getName().equals("YangInstanceIdentifier")) {
562 yangInstanceIdentifier = type;
563 } else if (type.getName().equals("YangBits")) {
566 } else if (type instanceof Enumeration) {
567 if (type.getName().equals("YangEnumeration")) {
568 yangEnumeration = type;
573 assertNotNull(yangBoolean);
574 assertNotNull(yangEmpty);
575 assertNotNull(yangEnumeration);
576 assertNotNull(yangInt8);
577 assertNotNull(yangInt8Restricted);
578 assertNotNull(yangInt16);
579 assertNotNull(yangInt32);
580 assertNotNull(yangInt64);
581 assertNotNull(yangString);
582 assertNotNull(yangDecimal);
583 assertNotNull(yangUint8);
584 assertNotNull(yangUint16);
585 assertNotNull(yangUint32);
586 assertNotNull(yangUint64);
587 assertNotNull(yangUnion);
588 assertNotNull(yangBinary);
589 assertNotNull(yangBits);
590 assertNotNull(yangInstanceIdentifier);
593 @Test(expected = IllegalArgumentException.class)
594 public void generatedTypeForExtendedDefinitionTypeWithTypedefNullTest() {
595 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
596 provider.generatedTypeForExtendedDefinitionType(null, null);
599 @Test(expected = IllegalArgumentException.class)
600 public void generatedTypeForExtendedDefinitionTypeWithTypedefQNameNullTest() {
601 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
602 final TestIntegerTypeDefinition testInt = new TestIntegerTypeDefinition();
603 provider.generatedTypeForExtendedDefinitionType(testInt, testInt);
607 public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
608 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
610 final Module baseYangTypes = resolveModule("test-type-provider");
611 final TypeDefinition<?> extYangInt8Typedef = resolveTypeDefinitionFromModule(baseYangTypes,
612 "extended-yang-int8");
613 assertNotNull(extYangInt8Typedef);
614 final Type extType = provider.generatedTypeForExtendedDefinitionType(extYangInt8Typedef, extYangInt8Typedef);
615 assertNotNull(extType);
616 assertTrue(extType instanceof GeneratedTransferObject);
620 public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
621 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
623 final Module baseYangTypes = resolveModule("test-type-provider");
624 final TypeDefinition<?> barItemLeafrefId = resolveTypeDefinitionFromModule(baseYangTypes, "bar-item-leafref-id");
625 assertNotNull(barItemLeafrefId);
626 final Type extType = provider.generatedTypeForExtendedDefinitionType(barItemLeafrefId, barItemLeafrefId);
627 assertEquals(null, extType);
631 public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
632 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
634 final Module baseYangTypes = resolveModule("test-type-provider");
636 final TypeDefinition<?> aesIdentityrefType = resolveTypeDefinitionFromModule(baseYangTypes,
637 "aes-identityref-type");
639 assertNotNull(aesIdentityrefType);
640 final Type extType = provider.generatedTypeForExtendedDefinitionType(aesIdentityrefType, aesIdentityrefType);
641 assertEquals(null, extType);
644 @Test(expected = NullPointerException.class)
645 public void provideGeneratedTOBuilderForBitsTypeDefinitionWithNullTypedefTest() {
646 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
647 provider.provideGeneratedTOBuilderForBitsTypeDefinition(JavaTypeName.create("foo", "foo"), null, "foo");
651 public void getConstructorPropertyNameTest() {
652 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
654 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
656 final TypeDefinition<?> leafType = leaf.getType();
658 final String ctorPropertyName = provider.getConstructorPropertyName(leafType);
659 assertEquals("value", ctorPropertyName);
661 final String emptyStringName = provider.getConstructorPropertyName(leaf);
662 assertTrue(emptyStringName.isEmpty());
666 public void getParamNameFromTypeTest() {
667 final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
669 final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
671 final TypeDefinition<?> leafType = leaf.getType();
673 final String paramName = provider.getParamNameFromType(leafType);
674 assertEquals("yangInt8", paramName);
678 public void addUnitsToGenTOTest() {
679 final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(
680 JavaTypeName.create("test.package", "TestBuilder"));
682 CodegenTypeProvider.addUnitsToGenTO(builder, null);
683 GeneratedTransferObject genTO = builder.build();
684 assertTrue(genTO.getConstantDefinitions().isEmpty());
686 CodegenTypeProvider.addUnitsToGenTO(builder, "");
687 genTO = builder.build();
688 assertTrue(genTO.getConstantDefinitions().isEmpty());
690 CodegenTypeProvider.addUnitsToGenTO(builder, "125");
691 genTO = builder.build();
692 assertTrue(!genTO.getConstantDefinitions().isEmpty());
693 assertEquals(1, genTO.getConstantDefinitions().size());
694 assertEquals("_UNITS", genTO.getConstantDefinitions().get(0).getName());
695 assertEquals(genTO.getConstantDefinitions().get(0).getValue(), "\"125\"");
698 @Test(expected = NullPointerException.class)
699 public void getTypeDefaultConstructionLeafTypeNullTest() {
700 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
701 final TestLeafSchemaNode leafSchemaNode = new TestLeafSchemaNode();
702 provider.getTypeDefaultConstruction(leafSchemaNode, null);
705 @Test(expected = NullPointerException.class)
706 public void getTypeDefaultConstructionDefaultValueNullTest() {
707 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
708 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
709 provider.getTypeDefaultConstruction(leaf, null);
712 private static LeafSchemaNode provideLeafForGetDefaultConstructionTestCase(final String leafName) {
713 return provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "construction-type-test", leafName);
716 @Test(expected = UnsupportedOperationException.class)
717 public void getTypeDefaultConstructionDefaultValueForInstanceIdentifierTest() {
718 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
719 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("foo-container-id");
720 provider.getTypeDefaultConstruction(leaf, "NAN");
723 @Test(expected = UnsupportedOperationException.class)
724 public void getTypeDefaultConstructionDefaultValueForIdentityrefTest() {
725 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
726 final LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("aes-identityref-type");
727 provider.getTypeDefaultConstruction(leaf, "NAN");
731 public void getTypeDefaultConstructionDefaultValueTest() {
732 final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
734 LeafSchemaNode leaf = provideLeafForGetDefaultConstructionTestCase("yang-boolean");
735 String result = provider.getTypeDefaultConstruction(leaf, "true");
736 assertNotNull(result);
737 assertTrue(!result.isEmpty());
738 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBoolean(java.lang.Boolean.TRUE)",
741 leaf = provideLeafForGetDefaultConstructionTestCase("yang-empty");
742 result = provider.getTypeDefaultConstruction(leaf, "true");
743 assertNotNull(result);
744 assertTrue(!result.isEmpty());
745 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEmpty(java.lang.Boolean.TRUE)",
748 leaf = provideLeafForGetDefaultConstructionTestCase("yang-enumeration");
749 result = provider.getTypeDefaultConstruction(leaf, "a");
750 assertNotNull(result);
751 assertTrue(!result.isEmpty());
752 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangEnumeration.A",
755 leaf = provideLeafForGetDefaultConstructionTestCase("direct-use-of-enum");
756 result = provider.getTypeDefaultConstruction(leaf, "y");
757 assertNotNull(result);
758 assertTrue(!result.isEmpty());
759 assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.construction.type.test.DirectUseOfEnum.Y",
762 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8");
763 result = provider.getTypeDefaultConstruction(leaf, "17");
764 assertNotNull(result);
765 assertTrue(!result.isEmpty());
766 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"17\"))",
769 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int8-restricted");
770 result = provider.getTypeDefaultConstruction(leaf, "99");
771 assertNotNull(result);
772 assertTrue(!result.isEmpty());
773 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8Restricted(java.lang.Byte.valueOf(\"99\"))",
776 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int16");
777 result = provider.getTypeDefaultConstruction(leaf, "1024");
778 assertNotNull(result);
779 assertTrue(!result.isEmpty());
780 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"1024\"))",
783 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int32");
784 result = provider.getTypeDefaultConstruction(leaf, "1048576");
785 assertNotNull(result);
786 assertTrue(!result.isEmpty());
787 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt32(java.lang.Integer.valueOf(\"1048576\"))",
790 leaf = provideLeafForGetDefaultConstructionTestCase("yang-int64");
791 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
792 assertNotNull(result);
793 assertTrue(!result.isEmpty());
794 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt64(java.lang.Long.valueOf(\"1099511627776\"))",
797 leaf = provideLeafForGetDefaultConstructionTestCase("yang-string");
798 result = provider.getTypeDefaultConstruction(leaf, "TEST");
799 assertNotNull(result);
800 assertTrue(!result.isEmpty());
801 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangString(\"TEST\")",
804 leaf = provideLeafForGetDefaultConstructionTestCase("yang-decimal64");
805 result = provider.getTypeDefaultConstruction(leaf, "1274.25");
806 assertNotNull(result);
807 assertTrue(!result.isEmpty());
808 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangDecimal64(new java.math.BigDecimal(\"1274.25\"))",
811 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint8");
812 result = provider.getTypeDefaultConstruction(leaf, "128");
813 assertNotNull(result);
814 assertTrue(!result.isEmpty());
815 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint8(java.lang.Short.valueOf(\"128\"))",
818 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint16");
819 result = provider.getTypeDefaultConstruction(leaf, "1048576");
820 assertNotNull(result);
821 assertTrue(!result.isEmpty());
822 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint16(java.lang.Integer.valueOf(\"1048576\"))",
825 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint32");
826 result = provider.getTypeDefaultConstruction(leaf, "1099511627776");
827 assertNotNull(result);
828 assertTrue(!result.isEmpty());
829 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint32(java.lang.Long.valueOf(\"1099511627776\"))",
832 leaf = provideLeafForGetDefaultConstructionTestCase("yang-uint64");
833 result = provider.getTypeDefaultConstruction(leaf, "1208925819614629174706176");
834 assertNotNull(result);
835 assertTrue(!result.isEmpty());
836 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUint64(new java.math.BigInteger(\"1208925819614629174706176\"))",
839 //FIXME: Is this correct scenario and correct result?
840 leaf = provideLeafForGetDefaultConstructionTestCase("complex-union");
841 result = provider.getTypeDefaultConstruction(leaf, "75");
842 assertNotNull(result);
843 assertTrue(!result.isEmpty());
844 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexUnion(\"null\".toCharArray())",
847 //FIXME: Is this correct scenario and correct result?
848 leaf = provideLeafForGetDefaultConstructionTestCase("complex-string-int-union");
849 result = provider.getTypeDefaultConstruction(leaf, "TEST_UNION_STRING_DEFAULT");
850 assertNotNull(result);
851 assertTrue(!result.isEmpty());
852 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.ComplexStringIntUnion(\"null\".toCharArray())",
855 leaf = provideLeafForGetDefaultConstructionTestCase("simple-int-types-union");
856 result = provider.getTypeDefaultConstruction(leaf, "2048");
857 assertNotNull(result);
858 assertTrue(!result.isEmpty());
859 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangUnion(\"null\".toCharArray())",
863 leaf = provideLeafForGetDefaultConstructionTestCase("direct-union-leaf");
864 result = provider.getTypeDefaultConstruction(leaf);
865 assertNotNull(result);
866 assertTrue(!result.isEmpty());
867 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.DirectUnionLeaf(\"128\".toCharArray())",
870 final Module module = resolveModule("test-type-provider");
871 final QName leafUnionNode = QName.create(module.getQNameModule(), "root-union-leaf");
872 DataSchemaNode rootNode = module.getDataChildByName(leafUnionNode);
873 assertNotNull("leaf root-union-leaf is not present in root of module " + module.getName(), rootNode);
874 assertTrue(rootNode instanceof LeafSchemaNode);
875 leaf = (LeafSchemaNode) rootNode;
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.TestTypeProviderData.RootUnionLeaf(\"256\".toCharArray())",
882 leaf = provideLeafForGetDefaultConstructionTestCase("yang-binary");
883 result = provider.getTypeDefaultConstruction(leaf, "0xffffff");
884 assertNotNull(result);
885 assertTrue(!result.isEmpty());
886 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBinary(new byte[] {-45, 23, -33, 125, -9, -33})",
889 final QName leafBitsNode = QName.create(module.getQNameModule(), "root-bits-leaf");
890 rootNode = module.getDataChildByName(leafBitsNode);
891 assertNotNull("leaf bits-leaf is not present in root of module " + module.getName(), rootNode);
892 assertTrue(rootNode instanceof LeafSchemaNode);
893 leaf = (LeafSchemaNode) rootNode;
894 result = provider.getTypeDefaultConstruction(leaf);
895 assertNotNull(result);
896 assertTrue(!result.isEmpty());
897 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912.TestTypeProviderData.RootBitsLeaf(true, false, false)",
900 leaf = provideLeafForGetDefaultConstructionTestCase("yang-bits");
901 result = provider.getTypeDefaultConstruction(leaf, "only-10-Mb");
902 assertNotNull(result);
903 assertTrue(!result.isEmpty());
904 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangBits(false, false, true)",
907 leaf = provideLeafForGetDefaultConstructionTestCase("bar-id");
908 result = provider.getTypeDefaultConstruction(leaf, "128");
909 assertNotNull(result);
910 assertTrue(!result.isEmpty());
911 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt16(java.lang.Short.valueOf(\"128\"))",
914 leaf = provideLeafForGetDefaultConstructionTestCase("foo-leafref-value");
915 result = provider.getTypeDefaultConstruction(leaf, "32");
916 assertNotNull(result);
917 assertTrue(!result.isEmpty());
918 assertEquals("new org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914.YangInt8(java.lang.Byte.valueOf(\"32\"))",
921 leaf = provideLeafForGetDefaultConstructionTestCase("foo-cond-bar-item");
922 result = provider.getTypeDefaultConstruction(leaf, "10");
923 assertNotNull(result);
924 assertTrue(!result.isEmpty());
925 assertEquals("new java.lang.Object()",