codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/DOMSourceXMLStreamReaderTest.java

   1 /*
   2  * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.data.codec.xml;
   9
  10 import static org.junit.jupiter.api.Assertions.assertFalse;
  11 import static org.junit.jupiter.api.Assertions.assertNotNull;
  12
  13 import javax.xml.stream.XMLOutputFactory;
  14 import javax.xml.transform.dom.DOMResult;
  15 import javax.xml.transform.dom.DOMSource;
  16 import org.junit.jupiter.api.AfterAll;
  17 import org.junit.jupiter.api.BeforeAll;
  18 import org.junit.jupiter.params.ParameterizedTest;
  19 import org.junit.jupiter.params.provider.ArgumentsSource;
  20 import org.opendaylight.yangtools.util.xml.UntrustedXML;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
  23 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  24 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
  25 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  26 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
  27 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  28
  29 class DOMSourceXMLStreamReaderTest extends AbstractXmlTest {
  30     private static EffectiveModelContext SCHEMA_CONTEXT;
  31
  32     @BeforeAll
  33     static void beforeClass() {
  34         SCHEMA_CONTEXT = YangParserTestUtils.parseYang("""
  35             module bar {
  36               namespace bar-ns;
  37               prefix bar;
  38
  39               import foo {
  40                 prefix foo;
  41               }
  42
  43               augment "/foo:top-cont/foo:keyed-list" {
  44                 leaf iid-leaf {
  45                   type instance-identifier;
  46                 }
  47               }
  48             }""", """
  49             module baz {
  50               namespace baz-ns;
  51               prefix baz;
  52
  53               container top-cont {
  54                 /*list keyed-list {
  55                   key key-leaf;
  56                   leaf key-leaf {
  57                     type int32;
  58                   }
  59                 }*/
  60               }
  61             }""", """
  62             module foo {
  63               namespace foo-ns;
  64               prefix foo;
  65
  66               import rab {
  67                 prefix rab;
  68               }
  69
  70               container top-cont {
  71                 list keyed-list {
  72                   key key-leaf;
  73                   leaf key-leaf {
  74                     type int32;
  75                   }
  76                   leaf idref-leaf {
  77                     type identityref {
  78                       base rab:base-id;
  79                     }
  80                   }
  81                   leaf ordinary-leaf {
  82                     type int32;
  83                   }
  84                 }
  85               }
  86             }""", """
  87             module rab {
  88               namespace rab-ns;
  89               prefix rab;
  90
  91               import baz {
  92                 prefix baz;
  93               }
  94
  95               augment "/baz:top-cont" {
  96                 list keyed-list {
  97                   key key-leaf;
  98                   leaf key-leaf {
  99                     type int32;
 100                   }
 101                 }
 102               }
 103
 104               identity base-id;
 105
 106               identity id-foo {
 107                 base base-id;
 108               }
 109             }""", """
 110             module zab {
 111               namespace zab-ns;
 112               prefix zab;
 113
 114               import foo {
 115                 prefix foo;
 116               }
 117
 118               augment "/foo:top-cont/foo:keyed-list/" {
 119                 /*leaf ordinary-leaf {
 120                   type int32;
 121                 }*/
 122                 anyxml aug-anyxml;
 123               }
 124             }""");
 125     }
 126
 127     @AfterAll
 128     static void afterClass() {
 129         SCHEMA_CONTEXT = null;
 130     }
 131
 132     @ParameterizedTest(name = "{0}")
 133     @ArgumentsSource(TestFactories.class)
 134     void test(final String factoryMode, final XMLOutputFactory factory) throws Exception {
 135         // deserialization
 136         final var doc = loadDocument("/dom-reader-test/foo.xml");
 137         final var inputXml = new DOMSource(doc.getDocumentElement());
 138         var domXMLReader = new DOMSourceXMLStreamReader(inputXml);
 139
 140         final var result = new NormalizationResultHolder();
 141         final var streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 142         final var xmlParser = XmlParserStream.create(streamWriter,
 143             Inference.ofDataTreePath(SCHEMA_CONTEXT, QName.create("foo-ns", "top-cont")));
 144         xmlParser.parse(domXMLReader);
 145         final var transformedInput = result.getResult().data();
 146         assertNotNull(transformedInput);
 147
 148         // serialization
 149         //final StringWriter writer = new StringWriter();
 150         final var domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
 151         final var xmlStreamWriter = factory.createXMLStreamWriter(domResult);
 152
 153         final var xmlNormalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(
 154                 xmlStreamWriter, SCHEMA_CONTEXT);
 155
 156         final var normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(xmlNormalizedNodeStreamWriter);
 157         normalizedNodeWriter.write(transformedInput);
 158
 159         //final String serializedXml = writer.toString();
 160         final String serializedXml = toString(domResult.getNode());
 161         assertFalse(serializedXml.isEmpty());
 162     }
 163 }