View Javadoc
1   /*
2    * Copyright (C) 2013 4th Line GmbH, Switzerland
3    *
4    * The contents of this file are subject to the terms of either the GNU
5    * Lesser General Public License Version 2 or later ("LGPL") or the
6    * Common Development and Distribution License Version 1 or later
7    * ("CDDL") (collectively, the "License"). You may not use this file
8    * except in compliance with the License. See LICENSE.txt for more
9    * information.
10   *
11   * This program is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14   */
15  
16  package org.fourthline.cling.test.model;
17  
18  import org.fourthline.cling.model.ModelUtil;
19  import org.fourthline.cling.model.XMLUtil;
20  import org.testng.annotations.Test;
21  import org.w3c.dom.Document;
22  import org.w3c.dom.Element;
23  import org.xml.sax.InputSource;
24  
25  import javax.xml.parsers.DocumentBuilder;
26  import javax.xml.parsers.DocumentBuilderFactory;
27  import javax.xml.transform.OutputKeys;
28  import javax.xml.transform.Transformer;
29  import javax.xml.transform.TransformerFactory;
30  import javax.xml.transform.dom.DOMSource;
31  import javax.xml.transform.stream.StreamResult;
32  
33  import java.io.StringReader;
34  import java.io.StringWriter;
35  
36  import static org.testng.Assert.assertEquals;
37  
38  
39  public class UtilTest {
40  
41      final protected DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
42      final protected DocumentBuilder documentBuilder;
43  
44      public UtilTest() {
45          try {
46              this.documentBuilderFactory.setNamespaceAware(true);
47              this.documentBuilder = documentBuilderFactory.newDocumentBuilder();
48          } catch (Exception ex) {
49              throw new RuntimeException(ex);
50          }
51      }
52  
53      @Test
54      public void validUDAName() {
55          assertEquals(ModelUtil.isValidUDAName("in-valid"), false);
56  
57          assertEquals(ModelUtil.isValidUDAName("a_valid"), true);
58          assertEquals(ModelUtil.isValidUDAName("A_valid"), true);
59          assertEquals(ModelUtil.isValidUDAName("1_valid"), true);
60          assertEquals(ModelUtil.isValidUDAName("_valid"), true);
61  
62          assertEquals(ModelUtil.isValidUDAName("Some_Valid.Name"), true);
63          assertEquals(ModelUtil.isValidUDAName("XML_invalid"), false);
64          assertEquals(ModelUtil.isValidUDAName("xml_invalid"), false);
65      }
66  
67      @Test
68      public void csvToString() {
69  
70          Object[] plainStrings = new Object[]{"foo", "bar", "baz"};
71          assertEquals(ModelUtil.toCommaSeparatedList(plainStrings), "foo,bar,baz");
72  
73          Object[] commaStrings = new Object[]{"foo,", "bar", "b,az"};
74          assertEquals(ModelUtil.toCommaSeparatedList(commaStrings), "foo\\,,bar,b\\,az");
75  
76          Object[] backslashStrings = new Object[]{"f\\oo", "b,ar", "b\\az"};
77          assertEquals(ModelUtil.toCommaSeparatedList(backslashStrings), "f\\\\oo,b\\,ar,b\\\\az");
78      }
79  
80      @Test
81      public void stringToCsv() {
82  
83          Object[] plainStrings = new Object[]{"foo", "bar", "baz"};
84          assertEquals(ModelUtil.fromCommaSeparatedList("foo,bar,baz"), plainStrings);
85  
86          Object[] commaStrings = new Object[]{"foo,", "bar", "b,az"};
87          assertEquals(ModelUtil.fromCommaSeparatedList("foo\\,,bar,b\\,az"), commaStrings);
88  
89          Object[] backslashStrings = new Object[]{"f\\oo", "b,ar", "b\\az"};
90          assertEquals(ModelUtil.fromCommaSeparatedList("f\\\\oo,b\\,ar,b\\\\az"), backslashStrings);
91      }
92  
93  
94      @Test
95      public void printDOM1() throws Exception {
96          Document dom = documentBuilder.newDocument();
97          dom.setXmlStandalone(true); // ROTFL
98  
99          Element fooEl = dom.createElement("foo");
100         dom.appendChild(fooEl);
101 
102         Element barEl = dom.createElement("bar");
103         barEl.setAttribute("baz", "123");
104         fooEl.appendChild(barEl);
105 
106         barEl.setTextContent("abc");
107 
108         String xml = XMLUtil.documentToString(dom);
109 
110         assertEquals(xml, documentToString(dom));
111     }
112 
113     @Test
114     public void printDOM2() throws Exception {
115         Document dom = documentBuilder.newDocument();
116         dom.setXmlStandalone(true); // ROTFL
117 
118         Element fooEl = dom.createElementNS("urn:foo-bar:baz", "foo");
119         dom.appendChild(fooEl);
120 
121         Element barEl = dom.createElement("bar");
122         barEl.setAttribute("baz", "123");
123         fooEl.appendChild(barEl);
124 
125         barEl.setTextContent("abc");
126 
127         String xml = XMLUtil.documentToString(dom);
128 
129         assertEquals(xml, documentToString(dom));
130     }
131 
132     @Test
133     public void printDOM3() throws Exception {
134         Document dom = documentBuilder.newDocument();
135         dom.setXmlStandalone(true); // ROTFL
136 
137         Element fooEl = dom.createElementNS("urn:foo-bar:baz", "foo");
138         dom.appendChild(fooEl);
139 
140         Element barEl = dom.createElementNS("urn:foo-bar:abc", "bar");
141         barEl.setAttribute("baz", "123");
142         fooEl.appendChild(barEl);
143 
144         barEl.setTextContent("abc");
145 
146         String xml = XMLUtil.documentToString(dom);
147 
148         assertEquals(xml, documentToString(dom));
149     }
150 
151     @Test
152     public void printDOM4() throws Exception {
153         Document dom = documentBuilder.newDocument();
154         dom.setXmlStandalone(true); // ROTFL
155 
156         Element fooEl = dom.createElement("foo");
157         dom.appendChild(fooEl);
158 
159         Element barEl = dom.createElementNS("urn:foo-bar:baz", "bar");
160         barEl.setAttribute("baz", "123");
161         fooEl.appendChild(barEl);
162 
163         barEl.setTextContent("abc");
164 
165         String xml = XMLUtil.documentToString(dom);
166 
167         assertEquals(xml, documentToString(dom));
168     }
169 
170     @Test
171     public void printDOM5() throws Exception {
172         Document dom = documentBuilder.newDocument();
173         dom.setXmlStandalone(true); // ROTFL
174 
175         Element fooEl = dom.createElement("foo");
176         dom.appendChild(fooEl);
177 
178         Document dom2 = documentBuilder.newDocument();
179         dom2.setXmlStandalone(true);
180 
181         Element barEl = dom2.createElementNS("urn:foo-bar:baz", "bar");
182         barEl.setAttribute("baz", "123");
183         dom2.appendChild(barEl);
184 
185         Element bazEl = dom2.createElement("baz");
186         bazEl.setTextContent("baz");
187         barEl.appendChild(bazEl);
188 
189         String dom2XML = XMLUtil.documentToString(dom2);
190         Document dom2Reparesed = documentBuilder.parse(new InputSource(new StringReader(dom2XML)));
191         fooEl.appendChild(dom.importNode(dom2Reparesed.getDocumentElement(), true));
192 
193         String xml = XMLUtil.documentToString(dom);
194 
195         // We can't really test that, the order of attributes is different
196         assertEquals(xml.length(), documentToString(dom).length());
197     }
198 
199     @Test
200     public void printDOM6() throws Exception {
201         Document dom = documentBuilder.newDocument();
202         dom.setXmlStandalone(true); // ROTFL
203 
204         Element fooEl = dom.createElement("foo");
205         dom.appendChild(fooEl);
206 
207         Element barOneEl = dom.createElementNS("urn:same:space", "same:bar");
208         barOneEl.setTextContent("One");
209         fooEl.appendChild(barOneEl);
210 
211         Element barTwoEl = dom.createElementNS("urn:same:space", "same:bar");
212         barTwoEl.setTextContent("Two");
213         fooEl.appendChild(barTwoEl);
214 
215         String xml = XMLUtil.documentToString(dom);
216 
217         assertEquals(xml, documentToString(dom));
218     }
219 
220     @Test
221     public void printDOM7() throws Exception {
222         Document dom = documentBuilder.newDocument();
223         dom.setXmlStandalone(true); // ROTFL
224 
225         Element fooEl = dom.createElement("foo");
226         fooEl.setAttribute("bar", "baz");
227         dom.appendChild(fooEl);
228 
229         String xml = XMLUtil.documentToString(dom);
230 
231         assertEquals(xml, documentToString(dom));
232     }
233 
234     /* TODO: This is where I give up on Android 2.1
235     @Test
236     public void printDOM8() throws Exception {
237         Document dom = documentBuilder.newDocument();
238         dom.setXmlStandalone(true); // ROTFL
239 
240         Element fooEl = dom.createElementNS("urn:foo", "abc");
241         dom.appendChild(fooEl);
242 
243         fooEl.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:bar", "urn:bar");
244 
245         Element barEl = dom.createElementNS("urn:bar", "bar:def");
246         fooEl.appendChild(barEl);
247 
248         Element bar2El = dom.createElementNS("urn:bar", "bar:def2");
249         fooEl.appendChild(bar2El);
250 
251         String xml = XMLUtil.documentToString(dom);
252         System.out.println(xml);
253 
254         assertEquals(xml, documentToString(dom));
255     }
256     */
257 
258     public static String documentToString(Document document) throws Exception {
259         TransformerFactory transFactory = TransformerFactory.newInstance();
260         Transformer transformer = transFactory.newTransformer();
261         document.setXmlStandalone(true);
262         transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
263         transformer.setOutputProperty(OutputKeys.INDENT, "no");
264         transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
265         StringWriter out = new StringWriter();
266         transformer.transform(new DOMSource(document), new StreamResult(out));
267         return out.toString();
268     }
269 
270     @Test
271     public void parseTimeStrings() {
272         assertEquals(ModelUtil.fromTimeString("00:00:11.123"), 11);
273         assertEquals(ModelUtil.fromTimeString("00:00:11"), 11);
274         assertEquals(ModelUtil.fromTimeString("00:01:11"), 71);
275         assertEquals(ModelUtil.fromTimeString("01:01:11"), 3671);
276     }
277 
278     @Test(expectedExceptions = IllegalArgumentException.class)
279     public void parseInvalidTimeString() {
280         assertEquals(ModelUtil.fromTimeString("00-00:11.123"), 11);
281     }
282 
283 }