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.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(URI.create("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 = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf1))
228 .withValue("value1").build();
230 SystemLeafSetNode<?> myLeafListNode = Builders.leafSetBuilder()
231 .withNodeIdentifier(new NodeIdentifier(myLeafList))
232 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
233 new NodeWithValue<>(myLeafList, "lflvalue1")).withValue("lflvalue1").build())
234 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
235 new NodeWithValue<>(myLeafList, "lflvalue2")).withValue("lflvalue2").build()).build();
237 UserLeafSetNode<?> myOrderedLeafListNode = Builders.orderedLeafSetBuilder()
239 new NodeIdentifier(myOrderedLeafList))
240 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
241 new NodeWithValue<>(myOrderedLeafList, "olflvalue1")).withValue("olflvalue1").build())
242 .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
243 new NodeWithValue<>(myOrderedLeafList, "olflvalue2")).withValue("olflvalue2").build()).build();
245 ContainerNode myContainer1Node = Builders.containerBuilder().withNodeIdentifier(
246 new NodeIdentifier(myContainer1))
247 .withChild(myKeyedListNode)
248 .withChild(myOrderedListNode)
249 .withChild(myUnkeyedListNode)
250 .withChild(myLeaf1Node)
251 .withChild(myLeafListNode)
252 .withChild(myOrderedLeafListNode)
256 ContainerNode innerContainerNode = Builders.containerBuilder().withNodeIdentifier(
257 new NodeIdentifier(innerContainer))
258 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf2))
259 .withValue("value2").build()).build();
261 LeafNode<?> myLeaf3Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf3))
262 .withValue("value3").build();
264 ChoiceNode myChoiceNode = Builders.choiceBuilder().withNodeIdentifier(new NodeIdentifier(myChoice))
265 .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInCase2))
266 .withValue("case2value").build()).build();
268 DOMSourceAnyxmlNode myAnyxmlNode = Builders.anyXmlBuilder().withNodeIdentifier(new NodeIdentifier(myAnyxml))
269 .withValue(anyxmlDomSource).build();
271 ContainerNode myContainer2Node = Builders.containerBuilder().withNodeIdentifier(
272 new NodeIdentifier(myContainer2))
273 .withChild(innerContainerNode)
274 .withChild(myLeaf3Node)
275 .withChild(myChoiceNode).build();
276 //.withChild(myAnyxmlNode).build();
279 Map<QName, Object> keys = new HashMap<>();
280 keys.put(myFirstKeyLeaf, "listkeyvalue1");
281 keys.put(mySecondKeyLeaf, "listkeyvalue2");
283 MapNode myDoublyKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
284 .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
285 NodeIdentifierWithPredicates.of(myDoublyKeyedList, keys))
286 .withChild(Builders.leafBuilder().withNodeIdentifier(
287 new NodeIdentifier(myLeafInList3)).withValue("listleafvalue1").build()).build())
290 AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
291 new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
292 .withChild(myDoublyKeyedListNode).build();
294 ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
295 new NodeIdentifier(myContainer3))
296 .withChild(myDoublyKeyedListAugNode).build();
298 AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
299 new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
300 .withChild(myContainer3Node).build();
302 ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
303 new NodeIdentifier(outerContainer))
304 .withChild(myContainer1Node)
305 .withChild(myContainer2Node)
306 .withChild(myContainer3AugNode).build();
308 return outerContainerNode;
311 private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
312 final InputStream resourceAsStream = SchemalessXMLStreamNormalizedNodeStreamWriterTest.class
313 .getResourceAsStream(xmlPath);
314 return requireNonNull(readXmlToDocument(resourceAsStream));
317 private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
318 final Document doc = UntrustedXML.newDocumentBuilder().parse(xmlContent);
319 doc.getDocumentElement().normalize();
323 private static String toString(final Node xml) {
325 final Transformer transformer = TransformerFactory.newInstance().newTransformer();
326 transformer.setOutputProperty(OutputKeys.INDENT, "yes");
327 transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
329 final StreamResult result = new StreamResult(new StringWriter());
330 final DOMSource source = new DOMSource(xml);
331 transformer.transform(source, result);
333 return result.getWriter().toString();
334 } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
335 throw new RuntimeException("Unable to serialize xml element " + xml, e);