2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.yangtools.yang.data.codec.xml;
11 import static java.util.Objects.requireNonNull;
13 import com.google.common.collect.ImmutableSet;
14 import java.io.IOException;
15 import java.io.InputStream;
16 import java.io.StringWriter;
17 import java.util.ArrayList;
18 import java.util.Collection;
19 import java.util.HashMap;
20 import java.util.List;
22 import javax.xml.stream.XMLOutputFactory;
23 import javax.xml.stream.XMLStreamException;
24 import javax.xml.stream.XMLStreamWriter;
25 import javax.xml.transform.OutputKeys;
26 import javax.xml.transform.Transformer;
27 import javax.xml.transform.TransformerException;
28 import javax.xml.transform.TransformerFactory;
29 import javax.xml.transform.TransformerFactoryConfigurationError;
30 import javax.xml.transform.dom.DOMResult;
31 import javax.xml.transform.dom.DOMSource;
32 import javax.xml.transform.stream.StreamResult;
33 import org.custommonkey.xmlunit.Diff;
34 import org.custommonkey.xmlunit.DifferenceListener;
35 import org.custommonkey.xmlunit.IgnoreTextAndAttributeValuesDifferenceListener;
36 import org.custommonkey.xmlunit.XMLAssert;
37 import org.custommonkey.xmlunit.XMLUnit;
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.junit.runner.RunWith;
41 import org.junit.runners.Parameterized;
42 import org.opendaylight.yangtools.util.xml.UntrustedXML;
43 import org.opendaylight.yangtools.yang.common.QName;
44 import org.opendaylight.yangtools.yang.common.QNameModule;
45 import org.opendaylight.yangtools.yang.common.Revision;
46 import org.opendaylight.yangtools.yang.common.XMLNamespace;
47 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
48 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
51 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
52 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
57 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
58 import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
59 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
60 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
61 import org.opendaylight.yangtools.yang.data.api.schema.UserLeafSetNode;
62 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
63 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
64 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
65 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
66 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
67 import org.w3c.dom.Document;
68 import org.w3c.dom.Node;
69 import org.xml.sax.SAXException;
71 @RunWith(Parameterized.class)
72 public class SchemalessXMLStreamNormalizedNodeStreamWriterTest {
73 @Parameterized.Parameters(name = "{0}")
74 public static Collection<Object[]> data() {
75 return TestFactories.junitParameters();
78 private final XMLOutputFactory factory;
80 private QNameModule foobarModule;
82 private QName outerContainer;
84 private QName myContainer1;
85 private QName myKeyedList;
86 private QName myKeyLeaf;
87 private QName myLeafInList1;
88 private QName myLeafInList2;
89 private QName myOrderedList;
90 private QName myKeyLeafInOrderedList;
91 private QName myLeafInOrderedList1;
92 private QName myLeafInOrderedList2;
93 private QName myUnkeyedList;
94 private QName myLeafInUnkeyedList;
95 private QName myLeaf1;
96 private QName myLeafList;
97 private QName myOrderedLeafList;
99 private QName myContainer2;
100 private QName innerContainer;
101 private QName myLeaf2;
102 private QName myLeaf3;
103 private QName myChoice;
104 private QName myLeafInCase2;
105 private QName myAnyxml;
107 private QName myContainer3;
108 private QName myDoublyKeyedList;
109 private QName myFirstKeyLeaf;
110 private QName mySecondKeyLeaf;
111 private QName myLeafInList3;
113 private DOMSource anyxmlDomSource;
115 public SchemalessXMLStreamNormalizedNodeStreamWriterTest(final String factoryMode, final XMLOutputFactory factory) {
116 this.factory = factory;
120 public void setup() {
121 foobarModule = QNameModule.create(XMLNamespace.of("foobar-namespace"), Revision.of("2016-09-19"));
123 outerContainer = QName.create(foobarModule, "outer-container");
125 myContainer1 = QName.create(foobarModule, "my-container-1");
126 myKeyedList = QName.create(foobarModule, "my-keyed-list");
127 myKeyLeaf = QName.create(foobarModule, "my-key-leaf");
128 myLeafInList1 = QName.create(foobarModule, "my-leaf-in-list-1");
129 myLeafInList2 = QName.create(foobarModule, "my-leaf-in-list-2");
130 myOrderedList = QName.create(foobarModule, "my-ordered-list");
131 myKeyLeafInOrderedList = QName.create(foobarModule, "my-key-leaf-in-ordered-list");
132 myLeafInOrderedList1 = QName.create(foobarModule, "my-leaf-in-ordered-list-1");
133 myLeafInOrderedList2 = QName.create(foobarModule, "my-leaf-in-ordered-list-2");
134 myUnkeyedList = QName.create(foobarModule, "my-unkeyed-list");
135 myLeafInUnkeyedList = QName.create(foobarModule, "my-leaf-in-unkeyed-list");
136 myLeaf1 = QName.create(foobarModule, "my-leaf-1");
137 myLeafList = QName.create(foobarModule, "my-leaf-list");
138 myOrderedLeafList = QName.create(foobarModule, "my-ordered-leaf-list");
140 myContainer2 = QName.create(foobarModule, "my-container-2");
141 innerContainer = QName.create(foobarModule, "inner-container");
142 myLeaf2 = QName.create(foobarModule, "my-leaf-2");
143 myLeaf3 = QName.create(foobarModule, "my-leaf-3");
144 myChoice = QName.create(foobarModule, "my-choice");
145 myLeafInCase2 = QName.create(foobarModule, "my-leaf-in-case-2");
146 myAnyxml = QName.create(foobarModule, "my-anyxml");
148 myContainer3 = QName.create(foobarModule, "my-container-3");
149 myDoublyKeyedList = QName.create(foobarModule, "my-doubly-keyed-list");
150 myFirstKeyLeaf = QName.create(foobarModule, "my-first-key-leaf");
151 mySecondKeyLeaf = QName.create(foobarModule, "my-second-key-leaf");
152 myLeafInList3 = QName.create(foobarModule, "my-leaf-in-list-3");
154 anyxmlDomSource = new DOMSource();
158 public void testWrite() throws XMLStreamException, IOException, SAXException {
159 final Document doc = loadDocument("/foobar.xml");
161 final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
163 final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(domResult);
165 final NormalizedNodeStreamWriter schemalessXmlNormalizedNodeStreamWriter =
166 XMLStreamNormalizedNodeStreamWriter.createSchemaless(xmlStreamWriter);
168 final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
169 schemalessXmlNormalizedNodeStreamWriter);
171 normalizedNodeWriter.write(buildOuterContainerNode());
173 XMLUnit.setIgnoreWhitespace(true);
174 XMLUnit.setNormalize(true);
176 final String expectedXml = toString(doc.getDocumentElement());
177 final String serializedXml = toString(domResult.getNode());
178 final Diff diff = new Diff(expectedXml, serializedXml);
180 final DifferenceListener differenceListener = new IgnoreTextAndAttributeValuesDifferenceListener();
181 diff.overrideDifferenceListener(differenceListener);
183 XMLAssert.assertXMLEqual(diff, true);
186 private NormalizedNode buildOuterContainerNode() {
188 MapNode myKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myKeyedList))
189 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
190 NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue1"))
191 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
192 .withValue("listleafvalue1").build())
193 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
194 .withValue("listleafvalue2").build()).build())
195 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
196 NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue2"))
197 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
198 .withValue("listleafvalue12").build())
199 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
200 .withValue("listleafvalue22").build()).build()).build();
202 UserMapNode myOrderedListNode = Builders.orderedMapBuilder().withNodeIdentifier(
203 new NodeIdentifier(myOrderedList)).withChild(Builders.mapEntryBuilder().withNodeIdentifier(
204 NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue1"))
205 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList1))
206 .withValue("olistleafvalue1").build())
207 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList2))
208 .withValue("olistleafvalue2").build()).build())
209 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
210 NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue2"))
211 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList1))
212 .withValue("olistleafvalue12").build())
213 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList2))
214 .withValue("olistleafvalue22").build()).build()).build();
216 final UnkeyedListEntryNode unkeyedListEntry = Builders.unkeyedListEntryBuilder()
217 .withNodeIdentifier(new NodeIdentifier(myUnkeyedList))
218 .withChild(ImmutableNodes.leafNode(myLeafInUnkeyedList, "foo")).build();
220 final List<UnkeyedListEntryNode> unkeyedListEntries = new ArrayList<>();
221 unkeyedListEntries.add(unkeyedListEntry);
223 UnkeyedListNode myUnkeyedListNode = Builders.unkeyedListBuilder().withNodeIdentifier(
224 new NodeIdentifier(myUnkeyedList))
225 .withValue(unkeyedListEntries).build();
227 LeafNode<?> myLeaf1Node = ImmutableNodes.leafNode(myLeaf1, "value1");
229 SystemLeafSetNode<?> myLeafListNode = Builders.leafSetBuilder()
230 .withNodeIdentifier(new NodeIdentifier(myLeafList))
231 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
232 new NodeWithValue<>(myLeafList, "lflvalue1")).withValue("lflvalue1").build())
233 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
234 new NodeWithValue<>(myLeafList, "lflvalue2")).withValue("lflvalue2").build()).build();
236 UserLeafSetNode<?> myOrderedLeafListNode = Builders.orderedLeafSetBuilder()
237 .withNodeIdentifier(new NodeIdentifier(myOrderedLeafList))
238 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
239 new NodeWithValue<>(myOrderedLeafList, "olflvalue1")).withValue("olflvalue1").build())
240 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
241 new NodeWithValue<>(myOrderedLeafList, "olflvalue2")).withValue("olflvalue2").build()).build();
243 ContainerNode myContainer1Node = Builders.containerBuilder().withNodeIdentifier(
244 new NodeIdentifier(myContainer1))
245 .withChild(myKeyedListNode)
246 .withChild(myOrderedListNode)
247 .withChild(myUnkeyedListNode)
248 .withChild(myLeaf1Node)
249 .withChild(myLeafListNode)
250 .withChild(myOrderedLeafListNode)
254 ContainerNode innerContainerNode = Builders.containerBuilder().withNodeIdentifier(
255 new NodeIdentifier(innerContainer))
256 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf2))
257 .withValue("value2").build()).build();
259 LeafNode<?> myLeaf3Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf3))
260 .withValue("value3").build();
262 ChoiceNode myChoiceNode = Builders.choiceBuilder().withNodeIdentifier(new NodeIdentifier(myChoice))
263 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInCase2))
264 .withValue("case2value").build()).build();
266 DOMSourceAnyxmlNode myAnyxmlNode = Builders.anyXmlBuilder().withNodeIdentifier(new NodeIdentifier(myAnyxml))
267 .withValue(anyxmlDomSource).build();
269 ContainerNode myContainer2Node = Builders.containerBuilder().withNodeIdentifier(
270 new NodeIdentifier(myContainer2))
271 .withChild(innerContainerNode)
272 .withChild(myLeaf3Node)
273 .withChild(myChoiceNode).build();
274 //.withChild(myAnyxmlNode).build();
277 Map<QName, Object> keys = new HashMap<>();
278 keys.put(myFirstKeyLeaf, "listkeyvalue1");
279 keys.put(mySecondKeyLeaf, "listkeyvalue2");
281 MapNode myDoublyKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
282 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
283 NodeIdentifierWithPredicates.of(myDoublyKeyedList, keys))
284 .withChild(Builders.leafBuilder().withNodeIdentifier(
285 new NodeIdentifier(myLeafInList3)).withValue("listleafvalue1").build()).build())
288 AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
289 new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
290 .withChild(myDoublyKeyedListNode).build();
292 ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
293 new NodeIdentifier(myContainer3))
294 .withChild(myDoublyKeyedListAugNode).build();
296 AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
297 new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
298 .withChild(myContainer3Node).build();
300 ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
301 new NodeIdentifier(outerContainer))
302 .withChild(myContainer1Node)
303 .withChild(myContainer2Node)
304 .withChild(myContainer3AugNode).build();
306 return outerContainerNode;
309 private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
310 final InputStream resourceAsStream = SchemalessXMLStreamNormalizedNodeStreamWriterTest.class
311 .getResourceAsStream(xmlPath);
312 return requireNonNull(readXmlToDocument(resourceAsStream));
315 private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
316 final Document doc = UntrustedXML.newDocumentBuilder().parse(xmlContent);
317 doc.getDocumentElement().normalize();
321 private static String toString(final Node xml) {
323 final Transformer transformer = TransformerFactory.newInstance().newTransformer();
324 transformer.setOutputProperty(OutputKeys.INDENT, "yes");
325 transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
327 final StreamResult result = new StreamResult(new StringWriter());
328 final DOMSource source = new DOMSource(xml);
329 transformer.transform(source, result);
331 return result.getWriter().toString();
332 } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
333 throw new RuntimeException("Unable to serialize xml element " + xml, e);