final EffectiveModelContext schemaContext) throws Exception {
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(xmlInputStream);
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
xmlParser.parse(reader);
}
import com.google.common.base.MoreObjects.ToStringHelper;
import java.io.IOException;
import java.net.URISyntaxException;
-import java.util.List;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.AbstractNormalizableAnydata;
import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.xml.sax.SAXException;
/**
@Override
protected void writeTo(final NormalizedNodeStreamWriter streamWriter, final EffectiveStatementInference inference)
throws IOException {
- final List<? extends EffectiveStatement<?, ?>> path = inference.statementPath();
- if (path.isEmpty()) {
- throw new IOException("Cannot handle empty inference " + inference);
- }
- final EffectiveStatement<?, ?> stmt = path.get(path.size() - 1);
- if (!(stmt instanceof SchemaNode)) {
- throw new IOException("Unhandled statement " + stmt);
- }
-
final XmlParserStream xmlParser;
try {
- xmlParser = XmlParserStream.create(streamWriter, inference.getEffectiveModelContext(), (SchemaNode) stmt);
+ xmlParser = XmlParserStream.create(streamWriter, inference);
} catch (IllegalArgumentException e) {
throw new IOException("Failed to instantiate XML parser", e);
}
@Override
public void writeTo(final NormalizedNodeStreamWriter writer, final MountPointContext mountCtx) throws IOException {
-
final XmlParserStream xmlParser;
try {
- xmlParser = XmlParserStream.create(writer, mountCtx, mountCtx.getEffectiveModelContext());
+ xmlParser = XmlParserStream.create(writer, mountCtx);
} catch (IllegalArgumentException e) {
throw new IOException("Failed to instantiate XML parser", e);
}
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
// Cache of nsUri Strings to QNameModules, as inferred from document
private final Map<String, QNameModule> rawNamespaces = new HashMap<>();
private final NormalizedNodeStreamWriter writer;
+ private final SchemaInferenceStack stack;
private final XmlCodecFactory codecs;
private final DataSchemaNode parentNode;
private final boolean strictParsing;
private XmlParserStream(final NormalizedNodeStreamWriter writer, final XmlCodecFactory codecs,
- final DataSchemaNode parentNode, final boolean strictParsing) {
+ final SchemaInferenceStack stack, final boolean strictParsing) {
this.writer = requireNonNull(writer);
this.codecs = requireNonNull(codecs);
- this.parentNode = parentNode;
+ this.stack = requireNonNull(stack);
this.strictParsing = strictParsing;
+
+ if (!stack.isEmpty()) {
+ final EffectiveStatement<?, ?> stmt = stack.currentStatement();
+ if (stmt instanceof DataSchemaNode) {
+ parentNode = (DataSchemaNode) stmt;
+ } else if (stmt instanceof OperationDefinition) {
+ parentNode = OperationAsContainer.of((OperationDefinition) stmt);
+ } else {
+ throw new IllegalArgumentException("Illegal parent node " + stmt);
+ }
+ } else {
+ parentNode = stack.getEffectiveModelContext();
+ }
}
/**
* @return A new stream instance
*/
public static XmlParserStream create(final NormalizedNodeStreamWriter writer, final XmlCodecFactory codecs,
- final SchemaNode parentNode) {
+ final EffectiveStatementInference parentNode) {
return create(writer, codecs, parentNode, true);
}
* @return A new stream instance
*/
public static XmlParserStream create(final NormalizedNodeStreamWriter writer, final XmlCodecFactory codecs,
- final SchemaNode parentNode, final boolean strictParsing) {
- final DataSchemaNode parent;
- if (parentNode instanceof DataSchemaNode) {
- parent = (DataSchemaNode) parentNode;
- } else if (parentNode instanceof OperationDefinition) {
- parent = OperationAsContainer.of((OperationDefinition) parentNode);
- } else {
- throw new IllegalArgumentException("Illegal parent node " + parentNode);
- }
- return new XmlParserStream(writer, codecs, parent, strictParsing);
+ final EffectiveStatementInference parentNode, final boolean strictParsing) {
+ return new XmlParserStream(writer, codecs, SchemaInferenceStack.ofInference(parentNode), strictParsing);
+ }
+
+ /**
+ * Utility method for use when caching {@link XmlCodecFactory} is not feasible. Users with high performance
+ * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, EffectiveStatementInference)}
+ * instead and maintain a {@link XmlCodecFactory} to match the current {@link EffectiveModelContext}.
+ */
+ public static XmlParserStream create(final NormalizedNodeStreamWriter writer,
+ final EffectiveModelContext context) {
+ return create(writer, context, true);
+ }
+
+ /**
+ * Utility method for use when caching {@link XmlCodecFactory} is not feasible. Users with high performance
+ * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, EffectiveStatementInference)}
+ * instead and maintain a {@link XmlCodecFactory} to match the current {@link EffectiveModelContext}.
+ */
+ public static XmlParserStream create(final NormalizedNodeStreamWriter writer,
+ final EffectiveModelContext context, final boolean strictParsing) {
+ return create(writer, SchemaInferenceStack.of(context).toInference(), strictParsing);
}
/**
* Utility method for use when caching {@link XmlCodecFactory} is not feasible. Users with high performance
- * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, SchemaNode)} instead and
- * maintain a {@link XmlCodecFactory} to match the current {@link EffectiveModelContext}.
+ * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, EffectiveStatementInference)}
+ * instead and maintain a {@link XmlCodecFactory} to match the current {@link EffectiveModelContext}.
*/
public static XmlParserStream create(final NormalizedNodeStreamWriter writer,
- final EffectiveModelContext schemaContext, final SchemaNode parentNode) {
- return create(writer, schemaContext, parentNode, true);
+ final EffectiveStatementInference parentNode) {
+ return create(writer, parentNode, true);
}
/**
* Utility method for use when caching {@link XmlCodecFactory} is not feasible. Users with high performance
- * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, SchemaNode)} instead and
- * maintain a {@link XmlCodecFactory} to match the current {@link EffectiveModelContext}.
+ * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, EffectiveStatementInference)}
+ * instead and maintain a {@link XmlCodecFactory} to match the current {@link EffectiveModelContext}.
*/
public static XmlParserStream create(final NormalizedNodeStreamWriter writer,
- final EffectiveModelContext schemaContext, final SchemaNode parentNode, final boolean strictParsing) {
- return create(writer, XmlCodecFactory.create(schemaContext), parentNode, strictParsing);
+ final EffectiveStatementInference parentNode, final boolean strictParsing) {
+ return create(writer, XmlCodecFactory.create(parentNode.getEffectiveModelContext()), parentNode, strictParsing);
+ }
+
+ /**
+ * Utility method for use when caching {@link XmlCodecFactory} is not feasible. Users with high performance
+ * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, EffectiveStatementInference)}
+ * instead and maintain a {@link XmlCodecFactory} to match the current {@link MountPointContext}.
+ */
+ public static XmlParserStream create(final NormalizedNodeStreamWriter writer, final MountPointContext mountCtx) {
+ return create(writer, mountCtx, SchemaInferenceStack.of(mountCtx.getEffectiveModelContext()).toInference(),
+ true);
}
/**
* Utility method for use when caching {@link XmlCodecFactory} is not feasible. Users with high performance
- * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, SchemaNode)} instead and
- * maintain a {@link XmlCodecFactory} to match the current {@link MountPointContext}.
+ * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, EffectiveStatementInference)}
+ * instead and maintain a {@link XmlCodecFactory} to match the current {@link MountPointContext}.
*/
public static XmlParserStream create(final NormalizedNodeStreamWriter writer, final MountPointContext mountCtx,
- final SchemaNode parentNode) {
+ final EffectiveStatementInference parentNode) {
return create(writer, mountCtx, parentNode, true);
}
/**
* Utility method for use when caching {@link XmlCodecFactory} is not feasible. Users with high performance
- * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, SchemaNode)} instead and
- * maintain a {@link XmlCodecFactory} to match the current {@link MountPointContext}.
+ * requirements should use {@link #create(NormalizedNodeStreamWriter, XmlCodecFactory, EffectiveStatementInference)}
+ * instead and maintain a {@link XmlCodecFactory} to match the current {@link MountPointContext}.
*/
public static XmlParserStream create(final NormalizedNodeStreamWriter writer, final MountPointContext mountCtx,
- final SchemaNode parentNode, final boolean strictParsing) {
+ final EffectiveStatementInference parentNode, final boolean strictParsing) {
return create(writer, XmlCodecFactory.create(mountCtx), parentNode, strictParsing);
}
}
// We have a match, proceed with it
- read(in, ((CompositeNodeDataWithSchema<?>) parent).addChild(childDataSchemaNodes,
- elementList ? ChildReusePolicy.REUSE : ChildReusePolicy.NOOP), rootElement);
+ final QName qname = childDataSchemaNodes.peekLast().getQName();
+ final AbstractNodeDataWithSchema<?> child = ((CompositeNodeDataWithSchema<?>) parent).addChild(
+ childDataSchemaNodes, elementList ? ChildReusePolicy.REUSE : ChildReusePolicy.NOOP);
+ stack.enterDataTree(qname);
+ read(in, child, rootElement);
+ stack.exit();
continue;
}
import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
+import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
public class AnyXmlWithParamsParsingTest {
-
private static final InputStream EDIT_CONFIG = XmlToNormalizedNodesTest.class.getResourceAsStream(
"/anyxml-support/params/edit.xml");
- private static final EffectiveModelContext SCHEMA = YangParserTestUtils.parseYangResourceDirectory(
- "/anyxml-support/params/");
-
- private static final SchemaNode SCHEMA_NODE = SCHEMA.getOperations().stream()
- .filter(o -> o.getQName().getLocalName().equals("edit-config"))
- .findFirst()
- .map(OperationDefinition::getInput)
- .get();
+ private static final QNameModule IETF_NETCONF = QNameModule.create(
+ XMLNamespace.of("urn:ietf:params:xml:ns:netconf:base:1.0"), Revision.of("2011-06-01"));
@Test
public void testAnyXmlWithParams() throws Exception {
+ final EffectiveModelContext context = YangParserTestUtils.parseYangResourceDirectory("/anyxml-support/params/");
+
final Document doc = UntrustedXML.newDocumentBuilder().parse(EDIT_CONFIG);
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, SCHEMA, SCHEMA_NODE);
+ final XmlParserStream xmlParser = XmlParserStream.create(writer, SchemaInferenceStack.of(context,
+ Absolute.of(QName.create(IETF_NETCONF, "edit-config"), YangConstants.operationInputQName(IETF_NETCONF)))
+ .toInference());
xmlParser.traverse(new DOMSource(doc.getDocumentElement()));
final NormalizedNode parsed = resultHolder.getResult();
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.spi.DefaultSchemaTreeInference;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
public class AnydataNormalizeToContainerTest extends AbstractAnydataTest {
@Test
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT, anyDataSchemaNode);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, FOO_QNAME));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import java.io.IOException;
import java.net.URISyntaxException;
import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.xml.sax.SAXException;
public class AnydataParseTest extends AbstractAnydataTest {
-
@Test
public void testAnydata() throws XMLStreamException, IOException, URISyntaxException, SAXException {
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT,
- SCHEMA_CONTEXT.findDataChildByName(FOO_QNAME).get(), true);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, FOO_QNAME), true);
xmlParser.parse(reader);
- final NormalizedNode parsed = result.getResult();
- assertTrue(parsed instanceof AnydataNode);
+ assertThat(result.getResult(), instanceOf(AnydataNode.class));
}
}
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAnydataNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.util.ImmutableNormalizedAnydata;
-import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.spi.DefaultSchemaTreeInference;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
@Test
public void testXmlParseAnydata()
throws IOException, SAXException, XMLStreamException, URISyntaxException, TransformerException {
-
- //Create Data Scheme from yang file
- final SchemaNode dataSchemaNode = SCHEMA_CONTEXT.findDataTreeChild(FOO_QNAME).orElse(null);
- assertThat(dataSchemaNode, instanceOf(AnydataSchemaNode.class));
- final AnydataSchemaNode anyDataSchemaNode = (AnydataSchemaNode) dataSchemaNode;
-
// deserialization
final XMLStreamReader reader
= UntrustedXML.createXMLStreamReader(loadResourcesAsInputStream("/test-anydata.xml"));
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT, anyDataSchemaNode);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, FOO_QNAME));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
//Load XML from file and write it with xmlParseStream
final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(domResult);
- final AnydataSchemaNode anyDataSchemaNode = (AnydataSchemaNode) SCHEMA_CONTEXT.findDataTreeChild(FOO_QNAME)
- .orElseThrow();
final NormalizedNodeStreamWriter streamWriter = XMLStreamNormalizedNodeStreamWriter.create(
xmlStreamWriter, SCHEMA_CONTEXT);
final XMLStreamReader reader = new DOMSourceXMLStreamReader(domSource);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT, anyDataSchemaNode);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, FOO_QNAME));
xmlParser.parse(reader);
xmlParser.flush();
Document doc = loadXmlDocument("/test-anydata.xml");
final DOMSource domSource = new DOMSource(doc.getDocumentElement());
- //Get specific attribute from Yang file.
- final AnydataSchemaNode contWithAttr = (AnydataSchemaNode) SCHEMA_CONTEXT.findDataTreeChild(FOO_QNAME)
- .orElseThrow();
-
//Create NormalizedNodeResult
NormalizedNodeResult normalizedResult = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(normalizedResult);
//Initialize Reader with XML file
final XMLStreamReader reader = new DOMSourceXMLStreamReader(domSource);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT, contWithAttr);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, FOO_QNAME));
xmlParser.parse(reader);
xmlParser.flush();
import java.io.InputStream;
import javax.xml.stream.XMLStreamReader;
-import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug5396Test {
+ private static final QNameModule FOO = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2016-03-22"));
- private QNameModule fooModuleQName;
- private EffectiveModelContext schemaContext;
-
- @Before
- public void setUp() {
- fooModuleQName = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2016-03-22"));
- schemaContext = YangParserTestUtils.parseYangResource("/bug5396/yang/foo.yang");
- }
+ private final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug5396/yang/foo.yang");
@Test
public void test() throws Exception {
private void testInputXML(final String xmlPath, final String expectedValue) throws Exception {
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream(xmlPath);
- final Module fooModule = schemaContext.getModules().iterator().next();
- final ContainerSchemaNode rootCont = (ContainerSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "root")).get();
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, rootCont);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO, "root")));
xmlParser.parse(reader);
assertNotNull(result.getResult());
final ContainerNode rootContainer = (ContainerNode) result.getResult();
DataContainerChild myLeaf = rootContainer.childByArg(new NodeIdentifier(
- QName.create(fooModuleQName, "my-leaf")));
+ QName.create(FOO, "my-leaf")));
assertTrue(myLeaf instanceof LeafNode);
assertEquals(expectedValue, myLeaf.body());
}
* 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.yangtools.yang.data.codec.xml;
import static org.junit.Assert.assertNotNull;
import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug8083Test {
+ private static final QNameModule FOOBAR = QNameModule.create(XMLNamespace.of("foobar-ns"));
+ private static final QNameModule BAZ = QNameModule.create(XMLNamespace.of("baz-ns"));
+ private static final QNameModule ZAB = QNameModule.create(XMLNamespace.of("zab-ns"));
@Test
public void testInstanceIdentifierPathWithEmptyListKey() throws Exception {
final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/baz.yang");
- final Module bazModule = schemaContext.getModules().iterator().next();
- final ContainerSchemaNode topCont = (ContainerSchemaNode) bazModule.findDataChildByName(
- QName.create(bazModule.getQNameModule(), "top-cont")).get();
final InputStream resourceAsStream = Bug8083Test.class.getResourceAsStream("/bug8083/xml/baz.xml");
// deserialization
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topCont);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(BAZ, "top-cont")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
assertNotNull(transformedInput);
@Test
public void testInstanceIdentifierPathWithIdentityrefListKey() throws Exception {
final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/zab.yang");
- final Module zabModule = schemaContext.getModules().iterator().next();
- final ContainerSchemaNode topCont = (ContainerSchemaNode) zabModule.findDataChildByName(
- QName.create(zabModule.getQNameModule(), "top-cont")).get();
final InputStream resourceAsStream = Bug8083Test.class.getResourceAsStream("/bug8083/xml/zab.xml");
// deserialization
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topCont);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(ZAB, "top-cont")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
assertNotNull(transformedInput);
@Test
public void testInstanceIdentifierPathWithInstanceIdentifierListKey() throws Exception {
final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/foobar.yang");
- final Module foobarModule = schemaContext.getModules().iterator().next();
- final ContainerSchemaNode topCont = (ContainerSchemaNode) foobarModule.findDataChildByName(
- QName.create(foobarModule.getQNameModule(), "top-cont")).get();
final InputStream resourceAsStream = Bug8083Test.class.getResourceAsStream("/bug8083/xml/foobar.xml");
// deserialization
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topCont);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOOBAR, "top-cont")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
assertNotNull(transformedInput);
* 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.yangtools.yang.data.codec.xml;
import static org.junit.Assert.assertNotNull;
import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug8675Test {
+ private static final QNameModule FOO = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2017-06-13"));
private static EffectiveModelContext schemaContext;
- private static Module fooModule;
@BeforeClass
public static void setup() {
schemaContext = YangParserTestUtils.parseYangResource("/bug8675/foo.yang");
- fooModule = schemaContext.getModules().iterator().next();
}
@AfterClass
public static void cleanup() {
- fooModule = null;
schemaContext = null;
}
@Test
public void testParsingEmptyElements() throws Exception {
- final ContainerSchemaNode topLevelContainer = (ContainerSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-container")).get();
-
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream(
"/bug8675/foo.xml");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelContainer);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO, "top-level-container")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
@Test
public void testParsingEmptyRootElement() throws Exception {
- final ContainerSchemaNode topLevelContainer = (ContainerSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-container")).get();
-
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream(
"/bug8675/foo-2.xml");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelContainer);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO, "top-level-container")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
@Test
public void testListAsRootElement() throws Exception {
- final ListSchemaNode topLevelList = (ListSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-list")).get();
-
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/bug8675/foo-3.xml");
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelList);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO, "top-level-list")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
@Test
public void testAnyXmlAsRootElement() throws Exception {
- final AnyxmlSchemaNode topLevelAnyXml = (AnyxmlSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-anyxml")).get();
-
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/bug8675/foo-4.xml");
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelAnyXml);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO, "top-level-anyxml")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
@Test
public void testLeafAsRootElement() throws Exception {
- final LeafSchemaNode topLevelLeaf = (LeafSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-leaf")).get();
-
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/bug8675/foo-5.xml");
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelLeaf);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO, "top-level-leaf")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
@Test
public void testLeafListAsRootElement() throws Exception {
- final LeafListSchemaNode topLevelLeafList = (LeafListSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-leaf-list")).get();
-
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/bug8675/foo-6.xml");
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelLeafList);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO, "top-level-leaf-list")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
@Test
public void testParsingAttributes() throws Exception {
- final ContainerSchemaNode contWithAttr = (ContainerSchemaNode) SCHEMA_CONTEXT.findDataTreeChild(
- QName.create("foo", "cont-with-attributes")).orElseThrow();
-
final Document doc = loadDocument("/bug8745/foo.xml");
final DOMSource domSource = new DOMSource(doc.getDocumentElement());
xmlStreamWriter, SCHEMA_CONTEXT);
final XMLStreamReader reader = new DOMSourceXMLStreamReader(domSource);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT, contWithAttr);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, QName.create("foo", "cont-with-attributes")));
xmlParser.parse(reader);
XMLUnit.setIgnoreWhitespace(true);
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@RunWith(Parameterized.class)
@Test
public void test() throws Exception {
- final SchemaNode dataSchemaNode = SCHEMA_CONTEXT.findDataTreeChild(QName.create("foo-ns", "top-cont"))
- .orElse(null);
- assertThat(dataSchemaNode, instanceOf(ContainerSchemaNode.class));
- final ContainerSchemaNode topContSchema = (ContainerSchemaNode) dataSchemaNode;
-
final InputStream resourceAsStream = Bug8803Test.class.getResourceAsStream("/bug8803/foo.xml");
// deserialization
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT, topContSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, QName.create("foo-ns", "top-cont")));
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
assertNotNull(transformedInput);
import java.io.InputStream;
import java.util.Collection;
-import java.util.Optional;
import javax.xml.stream.XMLStreamReader;
-import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug890Test {
private static final QName OUTGOING_LABELS_QNAME = QName.create(FOO_MODULE, "outgoing-labels");
private static final QName INDEX_QNAME = QName.create(FOO_MODULE, "index");
- private EffectiveModelContext schemaContext;
-
- @Before
- public void setUp() throws Exception {
- schemaContext = YangParserTestUtils.parseYangResource("/bug890/yang/foo.yang");
- }
-
@Test
public void testinputXml() throws Exception {
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug890/yang/foo.yang");
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream("/bug890/xml/foo.xml");
- final Module fooModule = schemaContext.getModules().iterator().next();
- final Optional<DataSchemaNode> rootCont = fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "root"));
- assertTrue(rootCont.isPresent());
- ContainerSchemaNode containerSchemaNode = (ContainerSchemaNode) rootCont.get();
- assertNotNull(containerSchemaNode);
final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, containerSchemaNode);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create(FOO_MODULE, "root")));
xmlParser.parse(reader);
assertNotNull(result.getResult());
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
-import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
@Test
public void test() throws Exception {
- final ContainerSchemaNode outerContainerSchema = (ContainerSchemaNode) SchemaContextUtil
- .findNodeInSchemaContext(SCHEMA_CONTEXT, ImmutableList.of(QName.create("foo-ns", "top-cont")));
- assertNotNull(outerContainerSchema);
// deserialization
final Document doc = loadDocument("/dom-reader-test/foo.xml");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, SCHEMA_CONTEXT, outerContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(SCHEMA_CONTEXT, QName.create("foo-ns", "top-cont")));
xmlParser.parse(domXMLReader);
final NormalizedNode transformedInput = result.getResult();
assertNotNull(transformedInput);
* 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.yangtools.yang.data.codec.xml;
-import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.augmentationBuilder;
import org.junit.runners.Parameterized;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
});
}
- private static final String NAMESPACE = "urn:opendaylight:params:xml:ns:yang:controller:test";
- private static final Revision REVISION = Revision.of("2014-03-13");
+ private static final QNameModule MODULE = QNameModule.create(
+ XMLNamespace.of("urn:opendaylight:params:xml:ns:yang:controller:test"), Revision.of("2014-03-13"));
private static ContainerNode augmentChoiceHell2() {
final NodeIdentifier container = getNodeIdentifier("container");
}
private static NodeIdentifier getNodeIdentifier(final String localName) {
- return new NodeIdentifier(QName.create(XMLNamespace.of(NAMESPACE), REVISION, localName));
+ return new NodeIdentifier(QName.create(MODULE, localName));
}
private static AugmentationIdentifier getAugmentIdentifier(final String... childNames) {
return new AugmentationIdentifier(qn);
}
+ private final ContainerNode expectedNode;
+ private final String xmlPath;
+
public NormalizedNodeXmlTranslationTest(final String yangPath, final String xmlPath,
final ContainerNode expectedNode) {
this.schema = YangParserTestUtils.parseYangResource(yangPath);
this.xmlPath = xmlPath;
- this.containerNode = (ContainerSchemaNode) getSchemaNode(schema, "test", "container");
this.expectedNode = expectedNode;
}
- private final ContainerNode expectedNode;
- private final ContainerSchemaNode containerNode;
- private final String xmlPath;
-
@Test
public void testTranslationRepairing() throws Exception {
testTranslation(TestFactories.REPAIRING_OUTPUT_FACTORY);
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schema, containerNode);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schema, QName.create(MODULE, "container")));
xmlParser.parse(reader);
final NormalizedNode built = result.getResult();
throw new RuntimeException("Unable to serialize xml element " + xml, e);
}
}
-
- private static DataSchemaNode getSchemaNode(final SchemaContext context, final String moduleName,
- final String childNodeName) {
- for (Module module : context.getModules()) {
- if (module.getName().equals(moduleName)) {
- DataSchemaNode found = findChildNode(module, childNodeName);
- checkState(found != null, "Unable to find %s", childNodeName);
- return found;
- }
- }
- throw new IllegalStateException("Unable to find child node " + childNodeName);
- }
-
- // FIXME: duplicate of NormalizedDataBuilderTest.findChildNode()
- private static DataSchemaNode findChildNode(final DataNodeContainer container, final String name) {
- for (DataSchemaNode dataSchemaNode : container.getChildNodes()) {
- if (dataSchemaNode.getQName().getLocalName().equals(name)) {
- return dataSchemaNode;
- }
- if (dataSchemaNode instanceof DataNodeContainer) {
- DataSchemaNode retVal = findChildNode((DataNodeContainer) dataSchemaNode, name);
- if (retVal != null) {
- return retVal;
- }
- } else if (dataSchemaNode instanceof ChoiceSchemaNode) {
- for (CaseSchemaNode caseNode : ((ChoiceSchemaNode) dataSchemaNode).getCases()) {
- DataSchemaNode retVal = findChildNode(caseNode, name);
- if (retVal != null) {
- return retVal;
- }
- }
- }
- }
- return null;
- }
-
}
import java.io.InputStream;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class StrictParsingModeTest {
+ private static EffectiveModelContext schemaContext;
+
+ @BeforeClass
+ public static void beforeClass() {
+ schemaContext = YangParserTestUtils.parseYangResource("/strict-parsing-mode-test/foo.yang");
+ }
+
+ @AfterClass
+ public static void afterClass() {
+ schemaContext = null;
+ }
@Test
+ // unknown child nodes in the top-level-container node will be skipped when the strictParsing is set to false
public void testLenientParsing() throws Exception {
- // unknown child nodes in the top-level-container node will be skipped when the strictParsing is set to false
- final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource(
- "/strict-parsing-mode-test/foo.yang");
- final Module fooModule = schemaContext.getModules().iterator().next();
- final ContainerSchemaNode topLevelContainer = (ContainerSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-container")).get();
-
final InputStream resourceAsStream = StrictParsingModeTest.class.getResourceAsStream(
"/strict-parsing-mode-test/foo.xml");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelContainer, false);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create("foo", "top-level-container")), false);
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
}
@Test
+ // should fail because strictParsing is switched on and the top-level-container node contains child nodes
+ // which are not defined in the provided YANG model
public void testStrictParsing() throws Exception {
- // should fail because strictParsing is switched on and the top-level-container node contains child nodes
- // which are not defined in the provided YANG model
- final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource(
- "/strict-parsing-mode-test/foo.yang");
- final Module fooModule = schemaContext.getModules().iterator().next();
- final ContainerSchemaNode topLevelContainer = (ContainerSchemaNode) fooModule.findDataChildByName(
- QName.create(fooModule.getQNameModule(), "top-level-container")).get();
-
final InputStream resourceAsStream = StrictParsingModeTest.class.getResourceAsStream(
"/strict-parsing-mode-test/foo.xml");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelContainer, true);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, QName.create("foo", "top-level-container")), true);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString("Schema for node with name unknown-container-a and namespace foo "
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.xml.sax.SAXException;
private static final QName MY_LEAF_IN_LIST_3 = QName.create(BAZ_MODULE, "my-leaf-in-list-3");
private static EffectiveModelContext schemaContext;
- private static ContainerSchemaNode outerContainerSchema;
- private static ContainerSchemaNode parentContainerSchema;
+ private static Inference outerContainerSchema;
+ private static Inference parentContainerSchema;
@BeforeClass
public static void setup() {
schemaContext = YangParserTestUtils.parseYangResourceDirectory("/");
- parentContainerSchema = (ContainerSchemaNode) schemaContext.findDataTreeChild(PARENT_CONTAINER).orElseThrow();
- outerContainerSchema = (ContainerSchemaNode) schemaContext.findDataTreeChild(OUTER_CONTAINER).orElseThrow();
+ parentContainerSchema = Inference.ofDataTreePath(schemaContext, PARENT_CONTAINER);
+ outerContainerSchema = Inference.ofDataTreePath(schemaContext, OUTER_CONTAINER);
}
@AfterClass
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, outerContainerSchema);
xmlParser.parse(reader);
xmlParser.flush();
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, parentContainerSchema);
xmlParser.parse(reader);
final NormalizedNode transformedInput = result.getResult();
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, parentContainerSchema);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString("Duplicate element \"decimal64-leaf\" in namespace"
+ " \"foo-namespace\" with parent \"container leaf-container\" in XML input"));
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, parentContainerSchema);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString("Duplicate element \"my-anyxml\" in namespace"
+ " \"foo-namespace\" with parent \"container anyxml-container\" in XML input"));
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, parentContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, parentContainerSchema);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString("Duplicate element \"leaf-container\" in namespace"
+ " \"foo-namespace\" with parent \"container parent-container\" in XML input"));
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, outerContainerSchema);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString(" START_ELEMENT "));
}
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, outerContainerSchema);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString("</my-leaf-1>"));
}
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, outerContainerSchema);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString("</my-container-1>"));
}
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, outerContainerSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, outerContainerSchema);
final XMLStreamException ex = assertThrows(XMLStreamException.class, () -> xmlParser.parse(reader));
assertThat(ex.getMessage(), containsString("Schema for node with name my-container-1 and namespace "
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class YT1107Test {
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext,
- schemaContext.findDataTreeChild(PARENT).orElseThrow());
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter,
+ Inference.ofDataTreePath(schemaContext, PARENT));
xmlParser.parse(reader);
assertEquals(Builders.containerBuilder()
Code Review / yangtools.git / commitdiff