--- /dev/null
+/*
+ * Copyright (c) 2019 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.dom.codec.impl;
+
+import java.io.IOException;
+import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
+import org.opendaylight.yangtools.yang.binding.OpaqueObject;
+
+interface AnydataBindingStreamWriter extends BindingStreamEventWriter {
+
+ void anydataNode(String name, OpaqueObject<?> value) throws IOException;
+}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
final DataNodeContainer childSchema) {
final Map<String, DataSchemaNode> getterToLeafSchema = new HashMap<>();
for (final DataSchemaNode leaf : childSchema.getChildNodes()) {
- // FIXME: support AnyDataSchemaNode, too
- if (leaf instanceof TypedDataSchemaNode || leaf instanceof AnyXmlSchemaNode) {
+ if (leaf instanceof TypedDataSchemaNode || leaf instanceof AnyXmlSchemaNode
+ || leaf instanceof AnyDataSchemaNode) {
getterToLeafSchema.put(BindingSchemaMapping.getGetterMethodName(leaf), leaf);
}
}
final Codec<Object, Object> codec = getCodec(valueType, leafListSchema.getType());
valueNode = new LeafSetNodeCodecContext(leafListSchema, codec, method.getName());
} else if (schema instanceof AnyXmlSchemaNode) {
- final Class<?> valueType = method.getReturnType();
- verify(OpaqueObject.class.isAssignableFrom(valueType), "Illegal value type %s", valueType);
valueNode = new OpaqueNodeCodecContext.AnyXml<>((AnyXmlSchemaNode) schema, method.getName(),
- valueType.asSubclass(OpaqueObject.class), loader);
+ opaqueReturnType(method), loader);
+ } else if (schema instanceof AnyDataSchemaNode) {
+ valueNode = new OpaqueNodeCodecContext.AnyData<>((AnyDataSchemaNode) schema, method.getName(),
+ opaqueReturnType(method), loader);
} else {
verify(schema == null, "Unhandled schema %s for method %s", schema, method);
// We do not have schema for leaf, so we will ignore it (e.g. getClass).
public BindingCodecTreeNode getSubtreeCodec(final SchemaPath path) {
throw new UnsupportedOperationException("Not implemented yet.");
}
+
+ @SuppressWarnings("rawtypes")
+ private static Class<? extends OpaqueObject> opaqueReturnType(final Method method) {
+ final Class<?> valueType = method.getReturnType();
+ verify(OpaqueObject.class.isAssignableFrom(valueType), "Illegal value type %s", valueType);
+ return valueType.asSubclass(OpaqueObject.class);
+ }
}
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.AnydataExtension;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-final class BindingToNormalizedStreamWriter implements BindingStreamEventWriter, Delegator<NormalizedNodeStreamWriter> {
+final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWriter,
+ Delegator<NormalizedNodeStreamWriter> {
private final Deque<NodeCodecContext> schema = new ArrayDeque<>();
private final NormalizedNodeStreamWriter delegate;
private final NodeCodecContext rootNodeSchema;
delegate.endNode();
}
+ @Override
+ public void anydataNode(final String name, final OpaqueObject<?> value) throws IOException {
+ final AnydataExtension ext = delegate.getExtensions().getInstance(AnydataExtension.class);
+ if (ext != null) {
+ final Entry<NodeIdentifier, Object> dom = serializeLeaf(name, value);
+ if (ext.startAnydataNode(dom.getKey(), value.getValue().getObjectModel())) {
+ delegate.scalarValue(dom.getValue());
+ delegate.endNode();
+ }
+ }
+ }
+
@Override
public void anyxmlNode(final String name, final Object value) throws IOException {
final Entry<NodeIdentifier, Object> dom = serializeLeaf(name, value);
}
@Override
- protected BindingStreamEventWriter delegate() {
+ protected AnydataBindingStreamWriter delegate() {
return delegate;
}
package org.opendaylight.mdsal.binding.dom.codec.impl;
import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verify;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableClassToInstanceMap;
import org.opendaylight.yangtools.yang.binding.DataObjectSerializerImplementation;
import org.opendaylight.yangtools.yang.binding.DataObjectSerializerRegistry;
import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
+ protected static final void streamAnydata(final BindingStreamEventWriter writer, final String localName,
+ final Object value) throws IOException {
+ if (value != null && writer instanceof AnydataBindingStreamWriter) {
+ verify(value instanceof OpaqueObject, "Unexpected data %s", value);
+ ((AnydataBindingStreamWriter) writer).anydataNode(localName, (OpaqueObject<?>) value);
+ }
+ }
+
protected static final void streamAnyxml(final BindingStreamEventWriter writer, final String localName,
final Object value) throws IOException {
if (value != null) {
import org.opendaylight.yangtools.yang.binding.DataObjectSerializerRegistry;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
UNKNOWN_SIZE,
invokeMethod(BindingStreamEventWriter.class, "startUnkeyedListItem", int.class));
+ private static final StackManipulation STREAM_ANYDATA = invokeMethod(DataObjectStreamer.class,
+ "streamAnydata", BindingStreamEventWriter.class, String.class, Object.class);
private static final StackManipulation STREAM_ANYXML = invokeMethod(DataObjectStreamer.class,
"streamAnyxml", BindingStreamEventWriter.class, String.class, Object.class);
private static final StackManipulation STREAM_CHOICE = invokeMethod(DataObjectStreamer.class,
if (childSchema instanceof ChoiceSchemaNode) {
return choiceChildStream(getter);
}
+ if (childSchema instanceof AnyDataSchemaNode) {
+ return qnameChildStream(STREAM_ANYDATA, getter, childSchema);
+ }
if (childSchema instanceof AnyXmlSchemaNode) {
return qnameChildStream(STREAM_ANYXML, getter, childSchema);
}
import java.io.IOException;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.OpaqueObject;
//FIXME: Consider moving this to yang.binding.util.* in Be
-abstract class ForwardingBindingStreamEventWriter implements BindingStreamEventWriter {
+abstract class ForwardingBindingStreamEventWriter implements AnydataBindingStreamWriter {
- protected abstract BindingStreamEventWriter delegate();
+ protected abstract AnydataBindingStreamWriter delegate();
@Override
public void leafNode(final String localName, final Object value) throws IOException {
delegate().startAugmentationNode(augmentationType);
}
+ @Override
+ public void anydataNode(final String name, final OpaqueObject<?> value) throws IOException {
+ delegate().anydataNode(name, value);
+ }
+
@Override
public void anyxmlNode(final String name, final Object value) throws IOException {
delegate().anyxmlNode(name, value);
import org.opendaylight.yangtools.yang.binding.OpaqueData;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
import org.opendaylight.yangtools.yang.data.api.schema.ForeignDataNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
return Builders.anyXmlBuilder().withNodeIdentifier(getDomPathArgument())
.withValue((DOMSource) opaqueData.getData()).build();
}
+
+ @Override
+ T deserialize(final ForeignDataNode<?, ?> foreignData) {
+ // Streaming cannot support anything but DOMSource-based AnyxmlNodes.
+ verify(foreignData instanceof AnyXmlNode, "Variable node %s not supported yet", foreignData);
+ return super.deserialize(foreignData);
+ }
+ }
+
+ static final class AnyData<T extends OpaqueObject<T>> extends OpaqueNodeCodecContext<T> {
+ AnyData(final AnyDataSchemaNode schema, final String getterName, final Class<T> bindingClass,
+ final CodecClassLoader loader) {
+ super(schema, getterName, bindingClass, loader);
+ }
+
+ @Override
+ AnydataNode<?> serializedData(final OpaqueData<?> opaqueData) {
+ return buildAnydata(opaqueData);
+ }
+
+ private <M> @NonNull AnydataNode<M> buildAnydata(final OpaqueData<M> opaqueData) {
+ return Builders.anydataBuilder(opaqueData.getObjectModel()).withNodeIdentifier(getDomPathArgument())
+ .withValue(opaqueData.getData()).build();
+ }
}
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(OpaqueObject.class,
@Override
public final T deserialize(final NormalizedNode<?, ?> data) {
checkArgument(data instanceof ForeignDataNode, "Unexpected value %s", data);
- final ForeignDataNode<?, ?> foreignData = (ForeignDataNode<?, ?>) data;
- // Streaming cannot support anything but DOMSource-based AnyxmlNodes.
- verify(foreignData instanceof AnyXmlNode, "Variable node %s not supported yet", foreignData);
+ return deserialize((ForeignDataNode<?, ?>) data);
+ }
+ T deserialize(final ForeignDataNode<?, ?> foreignData) {
return bindingClass.cast(createBindingProxy(new ForeignOpaqueData<>(foreignData)));
}
--- /dev/null
+/*
+ * Copyright (c) 2019 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.dom.codec.test;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+
+import java.util.Map.Entry;
+import javax.xml.transform.dom.DOMSource;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.mdsal438.norev.Cont;
+import org.opendaylight.yang.gen.v1.mdsal438.norev.ContBuilder;
+import org.opendaylight.yang.gen.v1.mdsal438.norev.cont.ContAny;
+import org.opendaylight.yangtools.util.xml.UntrustedXML;
+import org.opendaylight.yangtools.yang.binding.AbstractOpaqueData;
+import org.opendaylight.yangtools.yang.binding.AbstractOpaqueObject;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.OpaqueData;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+public class AnydataLeafTest extends AbstractBindingCodecTest {
+ private static final NodeIdentifier CONT_NODE_ID = new NodeIdentifier(Cont.QNAME);
+
+ private DOMSource domSource;
+ private ContainerNode cont;
+
+ @Override
+ public void before() {
+ super.before();
+
+ final Document doc = UntrustedXML.newDocumentBuilder().newDocument();
+ final Element element = doc.createElement("foo");
+ domSource = new DOMSource(element);
+
+ cont = Builders.containerBuilder()
+ .withNodeIdentifier(CONT_NODE_ID)
+ .withChild(Builders.anydataBuilder(DOMSource.class)
+ .withNodeIdentifier(new NodeIdentifier(ContAny.QNAME))
+ .withValue(domSource)
+ .build())
+ .build();
+ }
+
+ @Test
+ public void testAnydataToBinding() {
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(
+ YangInstanceIdentifier.create(CONT_NODE_ID), cont);
+ assertEquals(InstanceIdentifier.create(Cont.class), entry.getKey());
+ final DataObject ldo = entry.getValue();
+ assertThat(ldo, instanceOf(Cont.class));
+
+ // So no... GrpAny should be null ..
+ final Cont contValue = (Cont) ldo;
+ assertNull(contValue.getGrpAny());
+
+ // ContAny is interesting
+ final ContAny anyCont = contValue.getContAny();
+ assertNotNull(anyCont);
+ assertEquals(ContAny.class, anyCont.implementedInterface());
+
+ final OpaqueData<?> value = anyCont.getValue();
+ assertNotNull(value);
+ assertEquals(DOMSource.class, value.getObjectModel());
+ assertSame(domSource, value.getData());
+
+ // Stable hashCode
+ final int hashOne = anyCont.hashCode();
+ final int hashTwo = anyCont.hashCode();
+ assertEquals(hashOne, hashTwo);
+
+ // Basic equality
+ assertNotEquals(anyCont, null);
+ assertEquals(anyCont, anyCont);
+ assertEquals(new FakeCont(), anyCont);
+ assertEquals(anyCont, new FakeCont());
+ assertNotEquals(anyCont, new TestNormalizedNodeCont());
+ assertNotEquals(new TestNormalizedNodeCont(), anyCont);
+ }
+
+ @Test
+ public void testAnydataFromBinding() {
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ InstanceIdentifier.create(Cont.class), new ContBuilder().setContAny(new FakeCont()).build());
+ assertEquals(YangInstanceIdentifier.create(CONT_NODE_ID), entry.getKey());
+ assertEquals(cont, entry.getValue());
+ }
+
+ private final class FakeData extends AbstractOpaqueData<DOMSource> {
+ @Override
+ public Class<DOMSource> getObjectModel() {
+ return DOMSource.class;
+ }
+
+ @Override
+ public DOMSource getData() {
+ return domSource;
+ }
+ }
+
+ private abstract static class AbstractTestCont extends AbstractOpaqueObject<ContAny> implements ContAny {
+
+ }
+
+ private final class FakeCont extends AbstractTestCont {
+ @Override
+ public OpaqueData<?> getValue() {
+ return new FakeData();
+ }
+ }
+
+ private final class TestNormalizedNodeCont extends AbstractTestCont {
+ @Override
+ public OpaqueData<?> getValue() {
+ return new AbstractOpaqueData<NormalizedNode>() {
+
+ @Override
+ public Class<NormalizedNode> getObjectModel() {
+ return NormalizedNode.class;
+ }
+
+ @Override
+ public NormalizedNode getData() {
+ return cont;
+ }
+ };
+ }
+ }
+}
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
+import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
listToGenType(context, typeBuilder, baseInterface, (ListSchemaNode) node, inGrouping);
} else if (node instanceof ChoiceSchemaNode) {
choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) node, inGrouping);
- } else if (node instanceof AnyXmlSchemaNode) {
- // FIXME: MDSAL-438: also cover AnyDataSchemaNode
- opaqueToGeneratedType(context, typeBuilder, (AnyXmlSchemaNode) node);
+ } else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
+ opaqueToGeneratedType(context, typeBuilder, node);
} else {
LOG.debug("Unable to add schema node {} as method in {}: unsupported type of node.", node.getClass(),
typeBuilder.getFullyQualifiedName());
}
private void opaqueToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent,
- final AnyXmlSchemaNode anyxmlNode) {
- if (!anyxmlNode.isAddedByUses()) {
+ final DataSchemaNode anyNode) {
+ if (!anyNode.isAddedByUses()) {
final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition(
- JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyxmlNode.getPath()),
- BindingMapping.getClassName(anyxmlNode.getQName())), anyxmlNode);
+ JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyNode.getPath()),
+ BindingMapping.getClassName(anyNode.getQName())), anyNode);
anyxmlTypeBuilder.addImplementsType(opaqueObject(anyxmlTypeBuilder)).addImplementsType(childOf(parent));
defaultImplementedInterace(anyxmlTypeBuilder);
- annotateDeprecatedIfNecessary(anyxmlNode.getStatus(), anyxmlTypeBuilder);
- context.addChildNodeType(anyxmlNode, anyxmlTypeBuilder);
+ annotateDeprecatedIfNecessary(anyNode.getStatus(), anyxmlTypeBuilder);
+ context.addChildNodeType(anyNode, anyxmlTypeBuilder);
- constructGetter(parent, anyxmlTypeBuilder.build(), anyxmlNode);
+ constructGetter(parent, anyxmlTypeBuilder.build(), anyNode);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2019 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.OpaqueObject;
+
+abstract class AbstractOpaqueTest {
+
+ static void assertOpaqueNode(final List<Type> types, final String ns, final String pkg, final String name) {
+ final JavaTypeName typeName = JavaTypeName.create("org.opendaylight.yang.gen.v1." + ns + ".norev" + pkg, name);
+ final Optional<Type> optType = types.stream().filter(t -> typeName.equals(t.getIdentifier())).findFirst();
+ assertTrue(optType.isPresent());
+ final Type type = optType.get();
+ assertTrue(type instanceof GeneratedType);
+ final GeneratedType genType = (GeneratedType) type;
+ final Iterator<Type> it = genType.getImplements().iterator();
+ final Type first = it.next();
+ assertTrue(first instanceof ParameterizedType);
+ assertEquals(JavaTypeName.create(OpaqueObject.class), ((ParameterizedType) first).getRawType().getIdentifier());
+
+ final Type second = it.next();
+ assertTrue(second instanceof ParameterizedType);
+ assertEquals(JavaTypeName.create(ChildOf.class), ((ParameterizedType) second).getRawType().getIdentifier());
+
+ assertFalse(it.hasNext());
+ }
+}
package org.opendaylight.mdsal.binding.generator.impl;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import java.util.Iterator;
import java.util.List;
-import java.util.Optional;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.model.api.GeneratedType;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.yangtools.yang.binding.ChildOf;
-import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
-public class Mdsal437Test {
+public class Mdsal437Test extends AbstractOpaqueTest {
@Test
public void generateAnyxmlTest() {
assertNotNull(types);
assertEquals(7, types.size());
- assertXmlNode(types, "", "Any");
- assertXmlNode(types, ".cont", "Cont");
- assertXmlNode(types, ".grp", "Grp");
-
- }
-
- private static void assertXmlNode(final List<Type> types, final String pkg, final String name) {
- final JavaTypeName typeName = JavaTypeName.create("org.opendaylight.yang.gen.v1.mdsal437.norev" + pkg, name);
- final Optional<Type> optType = types.stream().filter(t -> typeName.equals(t.getIdentifier())).findFirst();
- assertTrue(optType.isPresent());
- final Type type = optType.get();
- assertTrue(type instanceof GeneratedType);
- final GeneratedType genType = (GeneratedType) type;
- final Iterator<Type> it = genType.getImplements().iterator();
- final Type first = it.next();
- assertTrue(first instanceof ParameterizedType);
- assertEquals(JavaTypeName.create(OpaqueObject.class), ((ParameterizedType) first).getRawType().getIdentifier());
-
- final Type second = it.next();
- assertTrue(second instanceof ParameterizedType);
- assertEquals(JavaTypeName.create(ChildOf.class), ((ParameterizedType) second).getRawType().getIdentifier());
-
- assertFalse(it.hasNext());
+ assertOpaqueNode(types, "mdsal437", "", "Any");
+ assertOpaqueNode(types, "mdsal437", ".cont", "Cont");
+ assertOpaqueNode(types, "mdsal437", ".grp", "Grp");
}
}
--- /dev/null
+/*
+ * Copyright (c) 2019 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.List;
+import org.junit.Test;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+
+public class Mdsal438Test extends AbstractOpaqueTest {
+
+ @Test
+ public void generateAnydataTest() {
+ final SchemaContext context = YangParserTestUtils.parseYangResource("/mdsal438.yang");
+
+ final List<Type> types = new BindingGeneratorImpl().generateTypes(context);
+ assertNotNull(types);
+ assertEquals(7, types.size());
+
+ assertOpaqueNode(types, "mdsal438", "", "Any");
+ assertOpaqueNode(types, "mdsal438", ".cont", "Cont");
+ assertOpaqueNode(types, "mdsal438", ".grp", "Grp");
+ }
+}
--- /dev/null
+module mdsal438 {
+ yang-version 1.1;
+ prefix mdsal438;
+ namespace mdsal438;
+
+ grouping grp {
+ anydata grp;
+ }
+
+ container cont {
+ anydata cont;
+
+ uses grp;
+ }
+
+ list lst {
+ uses grp;
+ }
+
+ anydata any;
+}
+
--- /dev/null
+module mdsal438 {
+ yang-version 1.1;
+ prefix mdsal438;
+ namespace mdsal438;
+
+ grouping grp {
+ anydata grp-any;
+ }
+
+ container cont {
+ anydata cont-any;
+
+ uses grp;
+ }
+
+ list lst {
+ uses grp;
+ }
+
+ anydata any;
+}
+
Code Review / mdsal.git / commitdiff