Java SchemaContextUtil.findDataSchemaNode方法代码示例

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void findDataSchemaNodeTest2() throws URISyntaxException, IOException, YangSyntaxErrorException,
        ReactorException {
    // findDataSchemaNode(final SchemaContext context, final Module module,
    // final RevisionAwareXPath nonCondXPath) {

    final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
    final Module module = context.findModule(new URI("uri:my-module"), Revision.of("2014-10-07")).get();

    final GroupingDefinition grouping = getGroupingByName(module, "my-grouping");
    final SchemaNode testNode = grouping.getDataChildByName(QName.create(module.getQNameModule(),
            "my-leaf-in-gouping2"));

    final RevisionAwareXPath xpath = new RevisionAwareXPathImpl("my:my-grouping/my:my-leaf-in-gouping2", true);

    final SchemaNode foundNode = SchemaContextUtil.findDataSchemaNode(context, module, xpath);

    assertNotNull(foundNode);
    assertNotNull(testNode);
    assertEquals(testNode, foundNode);

}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void nodeTest() throws Exception {
    SchemaContext context = StmtTestUtils.parseYangSources(
        "/semantic-statement-parser/multiple-revisions/node-test");
    assertNotNull(context);

    QName root = QName.create("foo", "2016-04-06", "foo-root");
    QName container20160404 = QName.create("foo", "2016-04-06", "con20160404");
    SchemaNode findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, root,
        container20160404));
    assertTrue(findDataSchemaNode instanceof ContainerSchemaNode);

    QName container20160405 = QName.create("foo", "2016-04-06", "con20160405");
    findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, root,
        container20160405));
    assertTrue(findDataSchemaNode instanceof ContainerSchemaNode);

    QName container20160406 = QName.create("foo", "2016-04-06", "con20160406");
    findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, root,
        container20160406));
    assertNull(findDataSchemaNode);
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
/**
 * Find "proper" qname of unknown node in case it comes from a grouping
 */
private static QName findQNameFromGrouping(final DataNodeContainer subtree, final SchemaContext ctx, final UnknownSchemaNode unknownSchemaNode, final String localIdentityName) {
    QName identityQName = null;
    for (UsesNode usesNode : subtree.getUses()) {
        SchemaNode dataChildByName = SchemaContextUtil.findDataSchemaNode(ctx, usesNode.getGroupingPath());
        Module m = SchemaContextUtil.findParentModule(ctx, dataChildByName);
        List<UnknownSchemaNode> unknownSchemaNodes = dataChildByName.getUnknownSchemaNodes();
        if(Collections2.transform(unknownSchemaNodes, UNKNOWN_NODE_TO_STRING).contains(UNKNOWN_NODE_TO_STRING.apply(unknownSchemaNode))) {
            identityQName = QName.create(dataChildByName.getQName(), localIdentityName);
        }
    }
    return identityQName;
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void testInvalidAugment2() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6669/invalid/test2");
    assertNotNull(context);

    final SchemaNode findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context,
            SchemaPath.create(true, ROOT, BAR, BAR_1, BAR_2, M));
    assertNull(findDataSchemaNode);
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
    public void testParsingAttributes() throws Exception {
        final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug8745/foo.yang");
        final QName contWithAttributes = QName.create("foo", "cont-with-attributes");
        final ContainerSchemaNode contWithAttr = (ContainerSchemaNode) SchemaContextUtil.findDataSchemaNode(
                schemaContext, SchemaPath.create(true, contWithAttributes));

        final Document doc = loadDocument("/bug8745/foo.xml");
        final DOMSource domSource = new DOMSource(doc.getDocumentElement());

        final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());

        final XMLOutputFactory outputfactory = XMLOutputFactory.newInstance();
        outputfactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);

        final XMLStreamWriter xmlStreamWriter = outputfactory.createXMLStreamWriter(domResult);

        final NormalizedNodeStreamWriter streamWriter = XMLStreamNormalizedNodeStreamWriter.create(
                xmlStreamWriter, schemaContext);

        final InputStream resourceAsStream = Bug8745Test.class.getResourceAsStream("/bug8745/foo.xml");
//        final XMLStreamReader reader = inputFactory.createXMLStreamReader(resourceAsStream);
        final XMLStreamReader reader = new DOMSourceXMLStreamReader(domSource);

        final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, contWithAttr);
        xmlParser.parse(reader);

        XMLUnit.setIgnoreWhitespace(true);
        XMLUnit.setNormalize(true);

        final String expectedXml = toString(doc.getDocumentElement());
        final String serializedXml = toString(domResult.getNode());
        final Diff diff = new Diff(expectedXml, serializedXml);

        XMLAssert.assertXMLEqual(diff, true);
    }
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void test() throws Exception {
    final SchemaContext schemaContext = YangParserTestUtils.parseYangResourceDirectory("/bug8803");
    final SchemaPath topContPath = SchemaPath.create(true, QName.create("foo-ns", "top-cont"));
    final SchemaNode dataSchemaNode = SchemaContextUtil.findDataSchemaNode(schemaContext, topContPath);
    assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
    final ContainerSchemaNode topContSchema = (ContainerSchemaNode) dataSchemaNode;

    final InputStream resourceAsStream = Bug8803Test.class.getResourceAsStream("/bug8803/foo.xml");

    // deserialization
    final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(resourceAsStream);

    final NormalizedNodeResult result = new NormalizedNodeResult();
    final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
    final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topContSchema);
    xmlParser.parse(reader);
    final NormalizedNode<?, ?> transformedInput = result.getResult();
    assertNotNull(transformedInput);

    // serialization
    final StringWriter writer = new StringWriter();
    final XMLOutputFactory outputFactory = XMLOutputFactory.newFactory();
    // switching NS repairing to false does not help
    outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
    final XMLStreamWriter xmlStreamWriter = outputFactory.createXMLStreamWriter(writer);

    final NormalizedNodeStreamWriter xmlNormalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(
            xmlStreamWriter, schemaContext);

    final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
            xmlNormalizedNodeStreamWriter);
    normalizedNodeWriter.write(transformedInput);

    final String serializedXml = writer.toString();
    assertFalse(serializedXml.isEmpty());
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void testValidAugment3() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6669/valid/test3");
    assertNotNull(context);

    final SchemaNode findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context,
            SchemaPath.create(true, ROOT, BAR, BAR_1, BAR_2, L));
    assertTrue(findDataSchemaNode instanceof ListSchemaNode);
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void test() throws Exception {
    SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5437");
    assertNotNull(context);

    QName root = QName.create(NS, REV, "root");
    QName leafRef2 = QName.create(NS, REV, "leaf-ref-2");
    QName conGrp = QName.create(NS, REV, "con-grp");
    QName leafRef = QName.create(NS, REV, "leaf-ref");

    SchemaPath leafRefPath = SchemaPath.create(true, root, conGrp, leafRef);
    SchemaPath leafRef2Path = SchemaPath.create(true, root, leafRef2);
    SchemaNode findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, leafRefPath);
    SchemaNode findDataSchemaNode2 = SchemaContextUtil.findDataSchemaNode(context, leafRef2Path);
    assertTrue(findDataSchemaNode instanceof LeafSchemaNode);
    assertTrue(findDataSchemaNode2 instanceof LeafSchemaNode);
    LeafSchemaNode leafRefNode = (LeafSchemaNode) findDataSchemaNode;
    LeafSchemaNode leafRefNode2 = (LeafSchemaNode) findDataSchemaNode2;

    assertTrue(leafRefNode.getType() instanceof LeafrefTypeDefinition);
    assertTrue(leafRefNode2.getType() instanceof LeafrefTypeDefinition);

    TypeDefinition<?> baseTypeForLeafRef = SchemaContextUtil.getBaseTypeForLeafRef(
            (LeafrefTypeDefinition) leafRefNode.getType(), context, leafRefNode);
    TypeDefinition<?> baseTypeForLeafRef2 = SchemaContextUtil.getBaseTypeForLeafRef(
            (LeafrefTypeDefinition) leafRefNode2.getType(), context, leafRefNode2);

    assertTrue(baseTypeForLeafRef instanceof BinaryTypeDefinition);
    assertTrue(baseTypeForLeafRef2 instanceof Int16TypeDefinition);
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
private static void checkRefinedList(final SchemaContext result, final SchemaPath path) {
    SchemaNode listInContainerNode = SchemaContextUtil.findDataSchemaNode(result, path);
    assertNotNull(listInContainerNode);

    ListSchemaNode listSchemaNode = (ListSchemaNode) listInContainerNode;
    assertEquals(Optional.of("new reference"), listSchemaNode.getReference());
    assertEquals(Optional.of("new description"), listSchemaNode.getDescription());
    assertTrue(listSchemaNode.isConfiguration());

    ElementCountConstraint listConstraints = listSchemaNode.getElementCountConstraint().get();
    assertEquals(5, listConstraints.getMinElements().intValue());
    assertEquals(7, listConstraints.getMaxElements().intValue());
    assertEquals(2, listSchemaNode.getMustConstraints().size());
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
private static AnyDataSchemaNode assertAnyData(final SchemaContext context, final Iterable<String> localNamesPath) {
    final Iterable<QName> qNames = Iterables.transform(localNamesPath,
        localName -> QName.create(FOO_NS, localName));
    final SchemaNode findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context,
            SchemaPath.create(qNames, true));
    assertTrue(findDataSchemaNode instanceof AnyDataSchemaNode);
    return (AnyDataSchemaNode) findDataSchemaNode;
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void test() throws Exception {
    SchemaContext context = reactor.newBuild()
            .addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource("/bugs/bug3874/foo.yang")))
            .addSource(YangStatementStreamSource.create(
                YangTextSchemaSource.forResource("/bugs/bug3874/yang-ext.yang")))
            .buildEffective();

    QNameModule foo = QNameModule.create(URI.create("foo"));
    QName myContainer2QName = QName.create(foo, "my-container-2");
    QName myAnyXmlDataQName = QName.create(foo, "my-anyxml-data");

    DataSchemaNode dataChildByName = context.getDataChildByName(myAnyXmlDataQName);
    assertTrue(dataChildByName instanceof YangModeledAnyXmlSchemaNode);
    YangModeledAnyXmlSchemaNode yangModeledAnyXml = (YangModeledAnyXmlSchemaNode) dataChildByName;

    SchemaNode myContainer2 = SchemaContextUtil.findDataSchemaNode(context,
        SchemaPath.create(true, myContainer2QName));
    assertTrue(myContainer2 instanceof ContainerSchemaNode);
    assertEquals(myContainer2, yangModeledAnyXml.getSchemaOfAnyXmlData());

    List<UnknownSchemaNode> unknownSchemaNodes = yangModeledAnyXml.getUnknownSchemaNodes();
    assertEquals(1, unknownSchemaNodes.size());

    UnknownSchemaNode next = unknownSchemaNodes.iterator().next();
    assertTrue(next instanceof AnyxmlSchemaLocationEffectiveStatementImpl);
    AnyxmlSchemaLocationEffectiveStatementImpl anyxmlSchemaLocationUnknownNode =
            (AnyxmlSchemaLocationEffectiveStatementImpl) next;
    assertEquals(OpenDaylightExtensionsStatements.ANYXML_SCHEMA_LOCATION.getStatementName(),
        anyxmlSchemaLocationUnknownNode.getNodeType());
    assertEquals(OpenDaylightExtensionsStatements.ANYXML_SCHEMA_LOCATION.getStatementName(),
        anyxmlSchemaLocationUnknownNode.getQName());
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void incorrectTest1() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5335/incorrect/case-1");
    assertNotNull(context);

    final SchemaPath schemaPath = SchemaPath.create(true, ROOT, NON_PRESENCE_CONTAINER_B, MANDATORY_LEAF_B);
    final SchemaNode mandatoryLeaf = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertNull(mandatoryLeaf);

    final String testLog = output.toString();
    assertTrue(testLog.contains(
        "An augment cannot add node 'mandatory-leaf' because it is mandatory and in module different than target"));
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test
public void test() throws Exception {
    SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5101");
    assertNotNull(context);

    QName grp = QName.create(NS, REV, "my-grouping");
    QName myContainer = QName.create(NS, REV, "my-container");
    QName root = QName.create(NS, REV, "root");

    SchemaNode findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context,
            SchemaPath.create(true, grp, myContainer));
    assertTrue(findDataSchemaNode instanceof ContainerSchemaNode);
    ContainerSchemaNode myContainerInGrouping = (ContainerSchemaNode) findDataSchemaNode;
    assertEquals(Status.DEPRECATED, myContainerInGrouping.getStatus());

    findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, root, myContainer));
    assertTrue(findDataSchemaNode instanceof ContainerSchemaNode);
    ContainerSchemaNode myContainerInRoot = (ContainerSchemaNode) findDataSchemaNode;
    assertEquals(Status.DEPRECATED, myContainerInRoot.getStatus());

    findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, myContainer));
    assertTrue(findDataSchemaNode instanceof ContainerSchemaNode);
    ContainerSchemaNode myContainerInModule = (ContainerSchemaNode) findDataSchemaNode;
    assertEquals(Status.DEPRECATED, myContainerInModule.getStatus());

    findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, root));
    assertTrue(findDataSchemaNode instanceof ContainerSchemaNode);
    ContainerSchemaNode rootContainer = (ContainerSchemaNode) findDataSchemaNode;
    assertEquals(Status.CURRENT, rootContainer.getStatus());
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
private static void checkRefinedChoice(final SchemaContext result, final SchemaPath path) {
    SchemaNode choiceInContainerNode = SchemaContextUtil.findDataSchemaNode(result, path);
    assertNotNull(choiceInContainerNode);

    ChoiceSchemaNode choiceSchemaNode = (ChoiceSchemaNode) choiceInContainerNode;
    assertTrue(choiceSchemaNode.isMandatory());
}
 

import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; //导入方法依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void findDataSchemaNodeFromXPathIllegalArgumentTest4() {

    final SchemaContext mockContext = Mockito.mock(SchemaContext.class);
    final Module module = Mockito.mock(Module.class);
    final RevisionAwareXPath xpath = new RevisionAwareXPathImpl(
            "my:my-grouping[@con='NULL']/my:my-leaf-in-gouping2", true);

    SchemaContextUtil.findDataSchemaNode(mockContext, module, xpath);

}