- Make generated type of choice implement Instantiable.
- Pass down the closest ancestor parent type (childOf) through
choice/cases to their children data nodes.
- Fix generate types from augmentd choice/cases as well as
unit tests.
- Cleanup GenHelperUtil a bit.
Change-Id: Id65d1025a173298dd25e70f36f9c8e3723d460c5
Signed-off-by: Jie Han <han.jie@zte.com.cn>
EnumBuilder addEnumeration(String name, ModuleContext context);
/**
- * Sets parent type for data schema node node builder
+ * Gets parent type for data schema node builder, the parent
+ * MUST be a data tree node.
*
- * @param type generated parent type
- * @return generated type
+ * @return parent generated type of tree node
+ */
+ Type getParentTypeForBuilder();
+
+ /**
+ * Sets parent type for data schema node builder, the parent
+ * MUST be a data tree node.
+ *
+ * @param type parent generated type of tree node
+ * @return parent generated type
*/
Type setParentTypeForBuilder(Type type);
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
+import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, augmentPackageName,
- targetTypeBuilder.toInstance(), targetSchemaNode, schemaPathAugmentListEntry.getValue(), genTypeBuilders, genCtx,
- schemaContext, verboseClassComments, typeProvider, BindingNamespaceType.Data);
+ targetTypeBuilder.toInstance(), targetSchemaNode, schemaPathAugmentListEntry.getValue(),
+ genTypeBuilders, genCtx, schemaContext, verboseClassComments, typeProvider, BindingNamespaceType.Data);
} else {
genCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, basePackageName,
- targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
- schemaPathAugmentListEntry.getValue(),
- null, genCtx, verboseClassComments, genTypeBuilders, typeProvider,
- BindingNamespaceType.Data);
+ targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
+ schemaPathAugmentListEntry.getValue(),genCtx, verboseClassComments, genTypeBuilders, typeProvider,
+ BindingNamespaceType.Data);
}
return genCtx;
}
@VisibleForTesting
static Map<Module, ModuleContext> generateTypesFromAugmentedChoiceCases(
final SchemaContext schemaContext, final Module module,
- final String basePackageName, final Type targetType, final ChoiceSchemaNode targetNode,
+ final String basePackageName, final GeneratedType targetType, final ChoiceSchemaNode targetNode,
final List<AugmentationSchemaNode> schemaPathAugmentListEntry,
- final DataNodeContainer usesNodeParent,
final Map<Module, ModuleContext> genCtx, final boolean verboseClassComments,
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
final BindingNamespaceType namespaceType) {
for (final AugmentationSchemaNode augmentationSchema : schemaPathAugmentListEntry) {
- for (final DataSchemaNode caseNode : augmentationSchema.getChildNodes()) {
- if (caseNode != null) {
- final GeneratedTypeBuilder caseTypeBuilder = GenHelperUtil.addDefaultInterfaceDefinition(basePackageName,
- caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
- namespaceType);
+ for (final DataSchemaNode childNode : augmentationSchema.getChildNodes()) {
+ if (childNode != null) {
+ final GeneratedTypeBuilder caseTypeBuilder =
+ GenHelperUtil.addDefaultInterfaceDefinition(basePackageName, childNode, null, module,
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(targetType);
+ caseTypeBuilder.setParentTypeForBuilder(targetType.getParentTypeForBuilder());
- SchemaNode parent;
- final SchemaPath nodeSp = targetNode.getPath();
- parent = SchemaContextUtil.findDataSchemaNode(schemaContext, nodeSp.getParent());
-
- GeneratedTypeBuilder childOfType = null;
- if (parent instanceof Module) {
- childOfType = genCtx.get(parent).getModuleNode();
- } else if (parent instanceof CaseSchemaNode) {
- childOfType = GenHelperUtil.findCaseByPath(parent.getPath(), genCtx);
- } else if (parent instanceof DataSchemaNode || parent instanceof NotificationDefinition) {
- childOfType = GenHelperUtil.findChildNodeByPath(parent.getPath(), genCtx);
- } else if (parent instanceof GroupingDefinition) {
- childOfType = GenHelperUtil.findGroupingByPath(parent.getPath(), genCtx);
- }
-
- if (childOfType == null) {
- throw new IllegalArgumentException("Failed to find parent type of choice " + targetNode);
- }
-
- CaseSchemaNode node = null;
- final String caseLocalName = caseNode.getQName().getLocalName();
- if (caseNode instanceof CaseSchemaNode) {
- node = (CaseSchemaNode) caseNode;
- } else if (findNamedCase(targetNode, caseLocalName) == null) {
- final String targetNodeLocalName = targetNode.getQName().getLocalName();
- for (DataSchemaNode dataSchemaNode : usesNodeParent.getChildNodes()) {
- if (dataSchemaNode instanceof ChoiceSchemaNode && targetNodeLocalName.equals(dataSchemaNode.getQName
- ().getLocalName())) {
- node = findNamedCase((ChoiceSchemaNode) dataSchemaNode, caseLocalName);
- break;
- }
- }
+ //Since uses augment nodes has been processed as inline nodes,
+ //we just take two situations below.
+ final CaseSchemaNode caseNode;
+ if (childNode instanceof CaseSchemaNode) {
+ caseNode = (CaseSchemaNode) childNode;
} else {
- node = findNamedCase(targetNode, caseLocalName);
+ caseNode = findNamedCase(targetNode, childNode.getQName().getLocalName());
+ if (caseNode == null) {
+ throw new IllegalArgumentException("Failed to find case node " + childNode);
+ }
}
- final Iterable<DataSchemaNode> childNodes = node.getChildNodes();
- if (childNodes != null) {
- GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType,
- childNodes, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
- namespaceType);
- processUsesImplements(node, module, schemaContext, genCtx, namespaceType);
+
+ final Collection<DataSchemaNode> childNodes = caseNode.getChildNodes();
+ if (!childNodes.isEmpty()) {
+ GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder,
+ (GeneratedTypeBuilder) targetType.getParentTypeForBuilder(), childNodes, genCtx,
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
}
- genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
- genCtx.get(module).addChoiceToCaseMapping(targetType, caseTypeBuilder, node);
+ genCtx.get(module).addCaseType(childNode.getPath(), caseTypeBuilder);
+ genCtx.get(module).addChoiceToCaseMapping(targetType, caseTypeBuilder, caseNode);
}
}
}
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
+import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
return module.equals(originalModule);
}
- static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
- schemaNode, final Module module, final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext,
- final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- return addDefaultInterfaceDefinition(basePackageName, schemaNode, null, module, genCtx, schemaContext,
- verboseClassComments, genTypeBuilders, typeProvider , namespaceType);
- }
-
private static QName createQNameFromSuperNode(final Module module, final Object node, final SchemaNode superChildNode) {
QName childNodeQName = null;
if (node instanceof Module) {
* string contains the module package name
* @param schemaNode
* schema node for which is created generated type builder
- * @param parent
- * parent type (can be null)
+ * @param childOf
+ * parent generated type of data tree node, which should be
+ * set null if current schema node is not a data tree node.
* @param schemaContext schema context
* @return generated type builder <code>schemaNode</code>
*/
- private static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
- schemaNode, final Type parent, final Module module, final Map<Module, ModuleContext> genCtx,
+ public static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
+ schemaNode, @Nullable final Type childOf, final Module module, final Map<Module, ModuleContext> genCtx,
final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String,
GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", "",
verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module));
+
if (namespaceType.equals(BindingNamespaceType.Data)) {
- if (parent == null) {
+ if (childOf == null) {
it.addImplementsType(BindingTypes.TREE_NODE);
} else {
if (!(schemaNode instanceof ListSchemaNode) ||
((ListSchemaNode) schemaNode).getKeyDefinition().isEmpty()) {
- it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
- (BindingTypes.ITEM, it)));
+ it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf,
+ parameterizedTypeFor(BindingTypes.ITEM, it)));
}
- it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it));
}
- if (!(schemaNode instanceof GroupingDefinition)) {
- it.addImplementsType(BindingTypes.augmentable(it));
+ if (!(schemaNode instanceof CaseSchemaNode)) {
+ it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it));
}
+
+ it.addImplementsType(BindingTypes.augmentable(it));
} else {
it.addImplementsType(BindingTypes.TREE_NODE);
}
verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
- notificationInterface.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, notificationInterface));
genCtx.get(module).addChildNodeType(notification, notificationInterface);
// Notification object
listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (node instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, childOf,
(ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
} else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
* </ul>
*/
private static void choiceToGenType(final Module module, final SchemaContext schemaContext, final boolean
- verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent, final
- ChoiceSchemaNode choiceNode, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
- final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+ verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent,
+ final GeneratedTypeBuilder childOf, final ChoiceSchemaNode choiceNode,
+ final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider,
+ final BindingNamespaceType namespaceType) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode,
- schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
+ schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType, genCtx.get(module));
constructGetter(parent, choiceNode.getQName().getLocalName(),
choiceNode.getDescription().orElse(null), choiceTypeBuilder, choiceNode.getStatus());
+ choiceTypeBuilder.setParentTypeForBuilder(childOf);
if (namespaceType.equals(BindingNamespaceType.Data)) {
choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder));
}
final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder);
genTOBuilder.addImplementsType(IDENTIFIER);
genType.addImplementsType(identifiableMarker);
- genType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
+ genType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, childOf, parameterizedTypeFor
(BindingTypes.IDENTIFIABLE_ITEM, genType, genTOBuilder)));
}
* </ul>
*/
private static void generateTypesFromChoiceCases(final Module module, final SchemaContext schemaContext,
- final Map<Module, ModuleContext> genCtx, final String basePackageName, final Type refChoiceType,
- final ChoiceSchemaNode choiceNode, final boolean verboseClassComments, final TypeProvider typeProvider,
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
+ final Map<Module, ModuleContext> genCtx, final String basePackageName, final GeneratedType refChoiceType,
+ final ChoiceSchemaNode choiceNode, final boolean verboseClassComments,
+ final TypeProvider typeProvider, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final BindingNamespaceType namespaceType) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) {
if (caseNode != null && resolveDataSchemaNodesCheck(module, schemaContext, caseNode)) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode,
- module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ null, module, genCtx, schemaContext, verboseClassComments,
+ genTypeBuilders, typeProvider, namespaceType);
caseTypeBuilder.addImplementsType(refChoiceType);
- caseTypeBuilder.setParentTypeForBuilder(refChoiceType);
+ caseTypeBuilder.setParentTypeForBuilder(refChoiceType.getParentTypeForBuilder());
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
- genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
- final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
- if (caseChildNodes != null) {
- final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent();
-
- if (!Iterables.isEmpty(choiceNodeParentPath.getPathFromRoot())) {
- SchemaNode parent = findDataSchemaNode(schemaContext, choiceNodeParentPath);
-
- if (parent instanceof AugmentationSchemaNode) {
- final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent;
- final SchemaPath targetPath = augSchema.getTargetPath();
- SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
- if (targetSchemaNode instanceof DataSchemaNode
- && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
- if (targetSchemaNode instanceof DerivableSchemaNode) {
- targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null);
- }
- if (targetSchemaNode == null) {
- throw new IllegalStateException(
- "Failed to find target node from grouping for augmentation " + augSchema
- + " in module " + module.getName());
- }
- }
- parent = targetSchemaNode;
- }
-
- Preconditions.checkState(parent != null, "Could not find Choice node parent %s",
- choiceNodeParentPath);
- GeneratedTypeBuilder childOfType = findChildNodeByPath(parent.getPath(), genCtx);
- if (childOfType == null) {
- childOfType = findGroupingByPath(parent.getPath(), genCtx);
- }
- resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes,
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
- } else {
- final GeneratedTypeBuilder moduleType = genCtx.get(module).getModuleNode();
- Preconditions.checkNotNull(moduleType, "Module type can not be null.");
- resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleType, caseChildNodes,
- genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
- }
- processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
+ if (namespaceType.equals(BindingNamespaceType.Data)) {
+ genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
}
+
+ resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder,
+ (GeneratedTypeBuilder) refChoiceType.getParentTypeForBuilder(), caseNode.getChildNodes(),
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ processUsesImplements(caseNode, module, schemaContext, genCtx, namespaceType);
}
}
}
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, typeBuilder,
(ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
}
}
listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
- choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+ choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder, typeBuilder,
(ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
}
}
private static Map<Module, ModuleContext> groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
module, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, module, genCtx,
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, null, module, genCtx,
schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
genCtx.get(module).addGroupingType(grouping, genType);
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
+import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
final SchemaContext schemaContext = null;
final Module module = null;
final String pckgName = null;
- final Type targetType = null;
+ final GeneratedType targetType = null;
final ChoiceSchemaNode targetNode = null;
final List<AugmentationSchemaNode> schemaPathAugmentListEntry = null;
- final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
try {
AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext, module, pckgName, targetType,
- targetNode, schemaPathAugmentListEntry, usesNodeParent, genCtx, false, genTypeBuilder, null,
+ targetNode, schemaPathAugmentListEntry, genCtx, false, genTypeBuilder, null,
BindingNamespaceType.Data);
fail();
} catch (final IllegalArgumentException e) {
final SchemaContext schemaContext = null;
final Module module = null;
final String pckgName = "";
- final Type targetType = null;
+ final GeneratedType targetType = null;
final ChoiceSchemaNode targetNode = null;
final List<AugmentationSchemaNode> schemaPathAugmentListEntry = null;
- final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
try {
AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext, module, pckgName, targetType,
- targetNode, schemaPathAugmentListEntry, usesNodeParent, genCtx, false, genTypeBuilder, null,
+ targetNode, schemaPathAugmentListEntry, genCtx, false, genTypeBuilder, null,
BindingNamespaceType.Data);
fail();
} catch (final IllegalArgumentException e) {
final SchemaContext schemaContext = null;
final Module module = null;
final String pckgName = "";
- final Type targetType = mock(Type.class);
+ final GeneratedType targetType = mock(GeneratedType.class);
final ChoiceSchemaNode targetNode = null;
final List<AugmentationSchemaNode> schemaPathAugmentListEntry = null;
- final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
- final Object[] args = { };
try {
AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext, module, pckgName, targetType,
- targetNode, schemaPathAugmentListEntry, usesNodeParent, genCtx, false, genTypeBuilder, null,
+ targetNode, schemaPathAugmentListEntry, genCtx, false, genTypeBuilder, null,
BindingNamespaceType.Data);
fail();
} catch (final IllegalArgumentException e) {
final SchemaContext schemaContext = null;
final Module module = null;
final String pckgName = "";
- final Type targetType = mock(Type.class);
+ final GeneratedType targetType = mock(GeneratedType.class);
final ChoiceSchemaNode targetNode = null;
final Set<DataSchemaNode> augmentNodes = new HashSet<>();
final DataSchemaNode caseNode = null;
final List<AugmentationSchemaNode> schemaPathAugmentListEntry = new ArrayList<>();
schemaPathAugmentListEntry.add(AugmentationSchemaNode);
- final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
final Map<Module, ModuleContext> result = AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext,
- module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent, genCtx, false,
+ module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, genCtx, false,
genTypeBuilder, null, BindingNamespaceType.Data);
assertEquals(genCtx, result);
}
- @Test
- public void generateTypesFromAugmentedChoiceCasesNullChildTest() {
- final QName qnamePath = QName.create("test", "2017-04-04", "chcase");
- final QName qnamePath2 = QName.create("test", "2017-04-04", "chcase2");
- final SchemaPath path = SchemaPath.create(true, qnamePath, qnamePath2);
-
- final SchemaContext schemaContext = mock(SchemaContext.class);
- final Module module = mock(Module.class);
- when(module.getName()).thenReturn("test-module-case");
- final DataSchemaNode schemaNode = mock(DataSchemaNode.class);
- when(module.getDataChildByName(qnamePath)).thenReturn(schemaNode);
- when(module.getRevision()).thenReturn(qnamePath.getRevision());
- when(module.getNamespace()).thenReturn(qnamePath.getNamespace());
- final String pckgName = "test.augment.choice.cases";
- final Type targetType = mock(Type.class);
- when(targetType.getFullyQualifiedName()).thenReturn(Augmentable.class.getName());
- final Set<DataSchemaNode> augmentNodes = new HashSet<>();
- final CaseSchemaNode caseNode = mock(CaseSchemaNode.class);
- when(caseNode.getPath()).thenReturn(path);
- when(caseNode.getQName()).thenReturn(qnamePath);
- when(caseNode.getDescription()).thenReturn(Optional.empty());
- when(caseNode.getReference()).thenReturn(Optional.empty());
-
- augmentNodes.add(caseNode);
-
- final AugmentationSchemaNode AugmentationSchemaNode = mock(AugmentationSchemaNode.class);
- when(AugmentationSchemaNode.getChildNodes()).thenReturn(augmentNodes);
- final List<AugmentationSchemaNode> schemaPathAugmentListEntry = new ArrayList<>();
- schemaPathAugmentListEntry.add(AugmentationSchemaNode);
-
- final DataNodeContainer usesNodeParent = null;
- final ChoiceSchemaNode targetNode = mock(ChoiceSchemaNode.class);
- when(targetNode.getPath()).thenReturn(path);
- when(targetNode.getDescription()).thenReturn(Optional.empty());
- when(targetNode.getReference()).thenReturn(Optional.empty());
-
- final Map<Module, ModuleContext> genCtx = new HashMap<>();
- genCtx.put(module, new ModuleContext());
- final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl(pckgName, "test-case-node-augment", genCtx.get(module));
- genCtx.get(module).addCaseType(path, gtb);
- final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
-
- when(schemaContext.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
-
- try {
- AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext, module, pckgName, targetType,
- targetNode, schemaPathAugmentListEntry, usesNodeParent, genCtx, false, genTypeBuilder, null,
- BindingNamespaceType.Data);
- fail();
- } catch (final IllegalArgumentException e) {
- assertEquals("Failed to find parent type of choice " + targetNode, e.getMessage());
- }
- }
-
@Test
public void generateTypesFromAugmentedChoiceCasesTest() {
final QName qnamePath = QName.create("test", "2017-04-04", "chcase");
when(module.getRevision()).thenReturn(qnamePath.getRevision());
when(module.getNamespace()).thenReturn(qnamePath.getNamespace());
final String pckgName = "test.augment.choice.cases";
- final Type targetType = mock(Type.class);
+ final GeneratedType targetType = mock(GeneratedType.class);
when(targetType.getFullyQualifiedName()).thenReturn(Augmentable.class.getName());
+
final Set<DataSchemaNode> augmentNodes = new HashSet<>();
final CaseSchemaNode caseNode = mock(CaseSchemaNode.class);
when(caseNode.getPath()).thenReturn(path);
final List<AugmentationSchemaNode> schemaPathAugmentListEntry = new ArrayList<>();
schemaPathAugmentListEntry.add(AugmentationSchemaNode);
- final DataNodeContainer usesNodeParent = null;
final ChoiceSchemaNode targetNode = mock(ChoiceSchemaNode.class);
when(targetNode.getPath()).thenReturn(path);
when(targetNode.getDescription()).thenReturn(Optional.empty());
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final ModuleContext moduleContext = new ModuleContext();
final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl(pckgName, "test-case-node-augment", moduleContext);
- moduleContext.addCaseType(path, gtb);
+ when(targetType.getParentTypeForBuilder()).thenReturn(gtb);
genCtx.put(module, moduleContext);
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
when(schemaContext.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
final Map<Module, ModuleContext> result = AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext,
- module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent, genCtx, false,
+ module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, genCtx, false,
genTypeBuilder, null, BindingNamespaceType.Data);
assertNotNull(result);
assertEquals(result.get(module), moduleContext);
return constant;
}
+
+
@Override
public Type setParentTypeForBuilder(Type type) {
return this.parentTypeForBuilder = type;
return null;
}
+ @Override
public Type getParentTypeForBuilder() {
return parentTypeForBuilder;
}
Code Review / mdsal.git / commitdiff