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;
18 import java.util.ArrayList;
19 import java.util.Collection;
20 import java.util.HashMap;
21 import java.util.List;
23 import javax.xml.stream.XMLOutputFactory;
24 import javax.xml.stream.XMLStreamException;
25 import javax.xml.stream.XMLStreamWriter;
26 import javax.xml.transform.OutputKeys;
27 import javax.xml.transform.Transformer;
28 import javax.xml.transform.TransformerException;
29 import javax.xml.transform.TransformerFactory;
30 import javax.xml.transform.TransformerFactoryConfigurationError;
31 import javax.xml.transform.dom.DOMResult;
32 import javax.xml.transform.dom.DOMSource;
33 import javax.xml.transform.stream.StreamResult;
34 import org.custommonkey.xmlunit.Diff;
35 import org.custommonkey.xmlunit.DifferenceListener;
36 import org.custommonkey.xmlunit.IgnoreTextAndAttributeValuesDifferenceListener;
37 import org.custommonkey.xmlunit.XMLAssert;
38 import org.custommonkey.xmlunit.XMLUnit;
39 import org.junit.Before;
40 import org.junit.Test;
41 import org.junit.runner.RunWith;
42 import org.junit.runners.Parameterized;
43 import org.opendaylight.yangtools.util.xml.UntrustedXML;
44 import org.opendaylight.yangtools.yang.common.QName;
45 import org.opendaylight.yangtools.yang.common.QNameModule;
46 import org.opendaylight.yangtools.yang.common.Revision;
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.AnyXmlNode;
52 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
57 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
58 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
59 import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
60 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
61 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
62 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
63 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
64 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
65 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
66 import org.w3c.dom.Document;
67 import org.w3c.dom.Node;
68 import org.xml.sax.SAXException;
70 @RunWith(Parameterized.class)
71 public class SchemalessXMLStreamNormalizedNodeStreamWriterTest {
72 @Parameterized.Parameters(name = "{0}")
73 public static Collection<Object[]> data() {
74 return TestFactories.junitParameters();
77 private final XMLOutputFactory factory;
79 private QNameModule foobarModule;
81 private QName outerContainer;
83 private QName myContainer1;
84 private QName myKeyedList;
85 private QName myKeyLeaf;
86 private QName myLeafInList1;
87 private QName myLeafInList2;
88 private QName myOrderedList;
89 private QName myKeyLeafInOrderedList;
90 private QName myLeafInOrderedList1;
91 private QName myLeafInOrderedList2;
92 private QName myUnkeyedList;
93 private QName myLeafInUnkeyedList;
94 private QName myLeaf1;
95 private QName myLeafList;
96 private QName myOrderedLeafList;
98 private QName myContainer2;
99 private QName innerContainer;
100 private QName myLeaf2;
101 private QName myLeaf3;
102 private QName myChoice;
103 private QName myLeafInCase2;
104 private QName myAnyxml;
106 private QName myContainer3;
107 private QName myDoublyKeyedList;
108 private QName myFirstKeyLeaf;
109 private QName mySecondKeyLeaf;
110 private QName myLeafInList3;
112 private DOMSource anyxmlDomSource;
114 public SchemalessXMLStreamNormalizedNodeStreamWriterTest(final String factoryMode, final XMLOutputFactory factory) {
115 this.factory = factory;
119 public void setup() {
120 foobarModule = QNameModule.create(URI.create("foobar-namespace"), Revision.of("2016-09-19"));
122 outerContainer = QName.create(foobarModule, "outer-container");
124 myContainer1 = QName.create(foobarModule, "my-container-1");
125 myKeyedList = QName.create(foobarModule, "my-keyed-list");
126 myKeyLeaf = QName.create(foobarModule, "my-key-leaf");
127 myLeafInList1 = QName.create(foobarModule, "my-leaf-in-list-1");
128 myLeafInList2 = QName.create(foobarModule, "my-leaf-in-list-2");
129 myOrderedList = QName.create(foobarModule, "my-ordered-list");
130 myKeyLeafInOrderedList = QName.create(foobarModule, "my-key-leaf-in-ordered-list");
131 myLeafInOrderedList1 = QName.create(foobarModule, "my-leaf-in-ordered-list-1");
132 myLeafInOrderedList2 = QName.create(foobarModule, "my-leaf-in-ordered-list-2");
133 myUnkeyedList = QName.create(foobarModule, "my-unkeyed-list");
134 myLeafInUnkeyedList = QName.create(foobarModule, "my-leaf-in-unkeyed-list");
135 myLeaf1 = QName.create(foobarModule, "my-leaf-1");
136 myLeafList = QName.create(foobarModule, "my-leaf-list");
137 myOrderedLeafList = QName.create(foobarModule, "my-ordered-leaf-list");
139 myContainer2 = QName.create(foobarModule, "my-container-2");
140 innerContainer = QName.create(foobarModule, "inner-container");
141 myLeaf2 = QName.create(foobarModule, "my-leaf-2");
142 myLeaf3 = QName.create(foobarModule, "my-leaf-3");
143 myChoice = QName.create(foobarModule, "my-choice");
144 myLeafInCase2 = QName.create(foobarModule, "my-leaf-in-case-2");
145 myAnyxml = QName.create(foobarModule, "my-anyxml");
147 myContainer3 = QName.create(foobarModule, "my-container-3");
148 myDoublyKeyedList = QName.create(foobarModule, "my-doubly-keyed-list");
149 myFirstKeyLeaf = QName.create(foobarModule, "my-first-key-leaf");
150 mySecondKeyLeaf = QName.create(foobarModule, "my-second-key-leaf");
151 myLeafInList3 = QName.create(foobarModule, "my-leaf-in-list-3");
153 anyxmlDomSource = new DOMSource();
157 public void testWrite() throws XMLStreamException, IOException, SAXException {
158 final Document doc = loadDocument("/foobar.xml");
160 final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
162 final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(domResult);
164 final NormalizedNodeStreamWriter schemalessXmlNormalizedNodeStreamWriter =
165 XMLStreamNormalizedNodeStreamWriter.createSchemaless(xmlStreamWriter);
167 final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
168 schemalessXmlNormalizedNodeStreamWriter);
170 normalizedNodeWriter.write(buildOuterContainerNode());
172 XMLUnit.setIgnoreWhitespace(true);
173 XMLUnit.setNormalize(true);
175 final String expectedXml = toString(doc.getDocumentElement());
176 final String serializedXml = toString(domResult.getNode());
177 final Diff diff = new Diff(expectedXml, serializedXml);
179 final DifferenceListener differenceListener = new IgnoreTextAndAttributeValuesDifferenceListener();
180 diff.overrideDifferenceListener(differenceListener);
182 XMLAssert.assertXMLEqual(diff, true);
185 private NormalizedNode<?, ?> buildOuterContainerNode() {
187 MapNode myKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myKeyedList))
188 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
189 NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue1"))
190 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
191 .withValue("listleafvalue1").build())
192 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
193 .withValue("listleafvalue2").build()).build())
194 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
195 NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue2"))
196 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
197 .withValue("listleafvalue12").build())
198 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
199 .withValue("listleafvalue22").build()).build()).build();
201 OrderedMapNode myOrderedListNode = Builders.orderedMapBuilder().withNodeIdentifier(
202 new NodeIdentifier(myOrderedList)).withChild(Builders.mapEntryBuilder().withNodeIdentifier(
203 NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue1"))
204 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList1))
205 .withValue("olistleafvalue1").build())
206 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList2))
207 .withValue("olistleafvalue2").build()).build())
208 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
209 NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue2"))
210 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList1))
211 .withValue("olistleafvalue12").build())
212 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInOrderedList2))
213 .withValue("olistleafvalue22").build()).build()).build();
215 final UnkeyedListEntryNode unkeyedListEntry = Builders.unkeyedListEntryBuilder()
216 .withNodeIdentifier(new NodeIdentifier(myUnkeyedList))
217 .withChild(ImmutableNodes.leafNode(myLeafInUnkeyedList, "foo")).build();
219 final List<UnkeyedListEntryNode> unkeyedListEntries = new ArrayList<>();
220 unkeyedListEntries.add(unkeyedListEntry);
222 UnkeyedListNode myUnkeyedListNode = Builders.unkeyedListBuilder().withNodeIdentifier(
223 new NodeIdentifier(myUnkeyedList))
224 .withValue(unkeyedListEntries).build();
226 LeafNode<?> myLeaf1Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf1))
227 .withValue("value1").build();
229 LeafSetNode<?> myLeafListNode = Builders.leafSetBuilder().withNodeIdentifier(new NodeIdentifier(myLeafList))
230 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
231 new NodeWithValue<>(myLeafList, "lflvalue1")).withValue("lflvalue1").build())
232 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
233 new NodeWithValue<>(myLeafList, "lflvalue2")).withValue("lflvalue2").build()).build();
235 LeafSetNode<?> myOrderedLeafListNode = Builders.orderedLeafSetBuilder().withNodeIdentifier(
236 new NodeIdentifier(myOrderedLeafList))
237 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
238 new NodeWithValue<>(myOrderedLeafList, "olflvalue1")).withValue("olflvalue1").build())
239 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
240 new NodeWithValue<>(myOrderedLeafList, "olflvalue2")).withValue("olflvalue2").build()).build();
242 ContainerNode myContainer1Node = Builders.containerBuilder().withNodeIdentifier(
243 new NodeIdentifier(myContainer1))
244 .withChild(myKeyedListNode)
245 .withChild(myOrderedListNode)
246 .withChild(myUnkeyedListNode)
247 .withChild(myLeaf1Node)
248 .withChild(myLeafListNode)
249 .withChild(myOrderedLeafListNode)
253 ContainerNode innerContainerNode = Builders.containerBuilder().withNodeIdentifier(
254 new NodeIdentifier(innerContainer))
255 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf2))
256 .withValue("value2").build()).build();
258 LeafNode<?> myLeaf3Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf3))
259 .withValue("value3").build();
261 ChoiceNode myChoiceNode = Builders.choiceBuilder().withNodeIdentifier(new NodeIdentifier(myChoice))
262 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInCase2))
263 .withValue("case2value").build()).build();
265 AnyXmlNode myAnyxmlNode = Builders.anyXmlBuilder().withNodeIdentifier(new NodeIdentifier(myAnyxml))
266 .withValue(anyxmlDomSource).build();
268 ContainerNode myContainer2Node = Builders.containerBuilder().withNodeIdentifier(
269 new NodeIdentifier(myContainer2))
270 .withChild(innerContainerNode)
271 .withChild(myLeaf3Node)
272 .withChild(myChoiceNode).build();
273 //.withChild(myAnyxmlNode).build();
276 Map<QName, Object> keys = new HashMap<>();
277 keys.put(myFirstKeyLeaf, "listkeyvalue1");
278 keys.put(mySecondKeyLeaf, "listkeyvalue2");
280 MapNode myDoublyKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
281 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
282 NodeIdentifierWithPredicates.of(myDoublyKeyedList, keys))
283 .withChild(Builders.leafBuilder().withNodeIdentifier(
284 new NodeIdentifier(myLeafInList3)).withValue("listleafvalue1").build()).build())
287 AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
288 new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
289 .withChild(myDoublyKeyedListNode).build();
291 ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
292 new NodeIdentifier(myContainer3))
293 .withChild(myDoublyKeyedListAugNode).build();
295 AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
296 new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
297 .withChild(myContainer3Node).build();
299 ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
300 new NodeIdentifier(outerContainer))
301 .withChild(myContainer1Node)
302 .withChild(myContainer2Node)
303 .withChild(myContainer3AugNode).build();
305 return outerContainerNode;
308 private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
309 final InputStream resourceAsStream = SchemalessXMLStreamNormalizedNodeStreamWriterTest.class
310 .getResourceAsStream(xmlPath);
311 return requireNonNull(readXmlToDocument(resourceAsStream));
314 private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
315 final Document doc = UntrustedXML.newDocumentBuilder().parse(xmlContent);
316 doc.getDocumentElement().normalize();
320 private static String toString(final Node xml) {
322 final Transformer transformer = TransformerFactory.newInstance().newTransformer();
323 transformer.setOutputProperty(OutputKeys.INDENT, "yes");
324 transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
326 final StreamResult result = new StreamResult(new StringWriter());
327 final DOMSource source = new DOMSource(xml);
328 transformer.transform(source, result);
330 return result.getWriter().toString();
331 } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
332 throw new RuntimeException("Unable to serialize xml element " + xml, e);