1 /*
2 * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package javax.xml.validation.ptests;
24
25 import static javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI;
26 import static javax.xml.validation.ptests.ValidationTestConst.XML_DIR;
27 import static org.testng.Assert.assertNotNull;
28 import static org.testng.Assert.assertNull;
29 import static org.testng.Assert.assertSame;
30
31 import java.io.ByteArrayInputStream;
32 import java.io.File;
33 import java.io.IOException;
34 import java.io.InputStream;
35 import java.net.URL;
36 import java.nio.file.Files;
37 import java.nio.file.Paths;
38
39 import javax.xml.parsers.DocumentBuilder;
40 import javax.xml.parsers.DocumentBuilderFactory;
41 import javax.xml.parsers.ParserConfigurationException;
42 import javax.xml.transform.Source;
43 import javax.xml.transform.dom.DOMSource;
44 import javax.xml.transform.sax.SAXSource;
45 import javax.xml.transform.stream.StreamSource;
46 import javax.xml.validation.Schema;
47 import javax.xml.validation.SchemaFactory;
48
49 import org.testng.annotations.BeforeClass;
50 import org.testng.annotations.DataProvider;
51 import org.testng.annotations.Test;
52 import org.w3c.dom.Document;
53 import org.xml.sax.ErrorHandler;
54 import org.xml.sax.InputSource;
55 import org.xml.sax.SAXException;
56 import org.xml.sax.SAXNotRecognizedException;
57 import org.xml.sax.SAXNotSupportedException;
58 import org.xml.sax.SAXParseException;
59
60 /*
61 * @summary Class containing the test cases for SchemaFactory
62 */
63 @Test(singleThreaded = true)
64 public class SchemaFactoryTest {
65
66 @BeforeClass
67 public void setup() throws SAXException, IOException, ParserConfigurationException {
68 sf = newSchemaFactory();
69
70 assertNotNull(sf);
71
72 xsd1 = Files.readAllBytes(Paths.get(XML_DIR + "test.xsd"));
73 xsd2 = Files.readAllBytes(Paths.get(XML_DIR + "test1.xsd"));
74
75 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
76 dbf.setNamespaceAware(true);
77 DocumentBuilder db = dbf.newDocumentBuilder();
78 xsdDoc1 = db.parse(newInputStream(xsd1));
79 xsdDoc2 = db.parse(newInputStream(xsd2));
80
81 xml = Files.readAllBytes(Paths.get(XML_DIR + "test.xml"));
82 }
83
84 @Test(expectedExceptions = SAXParseException.class)
85 public void testNewSchemaDefault() throws SAXException, IOException {
86 validate(sf.newSchema());
87 }
88
89 @Test
90 public void testNewSchemaWithFile() throws SAXException, IOException {
91 validate(sf.newSchema(new File(XML_DIR + "test.xsd")));
92 }
93
94 @Test(expectedExceptions = NullPointerException.class)
95 public void testNewSchemaWithNullFile() throws SAXException {
96 sf.newSchema((File) null);
97 }
98
99 @DataProvider(name = "valid-source")
100 public Object[][] getValidSource() {
101 return new Object[][] {
102 { streamSource(xsd1) },
103 { saxSource(xsd1) },
104 { domSource(xsdDoc1) } };
105
106 }
107
108 @Test(dataProvider = "valid-source")
109 public void testNewSchemaWithValidSource(Source schema) throws SAXException, IOException {
110 validate(sf.newSchema(schema));
111 }
112
113 @DataProvider(name = "invalid-source")
114 public Object[][] getInvalidSource() {
115 return new Object[][] {
116 { nullStreamSource() },
117 { nullSaxSource() } };
118 }
119
120 @Test(dataProvider = "invalid-source", expectedExceptions = SAXParseException.class)
121 public void testNewSchemaWithInvalidSource(Source schema) throws SAXException {
122 sf.newSchema(schema);
123 }
124
125 @Test(expectedExceptions = NullPointerException.class)
126 public void testNewSchemaWithNullSource() throws SAXException {
127 sf.newSchema((Source)null);
128 }
129
130 @DataProvider(name = "valid-sources")
131 public Object[][] getValidSources() {
132 return new Object[][] {
133 { streamSource(xsd1), streamSource(xsd2) },
134 { saxSource(xsd1), saxSource(xsd2) },
135 { domSource(xsdDoc1), domSource(xsdDoc2) } };
136
137 }
138
139 @Test(dataProvider = "valid-sources")
140 public void testNewSchemaWithValidSourceArray(Source schema1, Source schema2) throws SAXException, IOException {
141 validate(sf.newSchema(new Source[] { schema1, schema2 }));
142 }
143
144 @DataProvider(name = "invalid-sources")
145 public Object[][] getInvalidSources() {
146 return new Object[][] {
147 { streamSource(xsd1), nullStreamSource() },
148 { nullStreamSource(), nullStreamSource() },
149 { saxSource(xsd1), nullSaxSource() },
150 { nullSaxSource(), nullSaxSource() } };
151 }
152
153 @Test(dataProvider = "invalid-sources", expectedExceptions = SAXParseException.class)
154 public void testNewSchemaWithInvalidSourceArray(Source schema1, Source schema2) throws SAXException {
155 sf.newSchema(new Source[] { schema1, schema2 });
156 }
157
158 @DataProvider(name = "null-sources")
159 public Object[][] getNullSources() {
160 return new Object[][] {
161 { new Source[] { domSource(xsdDoc1), null } },
162 { new Source[] { null, null } },
163 { null } };
164
165 }
166
167 @Test(dataProvider = "null-sources", expectedExceptions = NullPointerException.class)
168 public void testNewSchemaWithNullSourceArray(Source[] schemas) throws SAXException {
169 sf.newSchema(schemas);
170 }
171
172 @Test(expectedExceptions = NullPointerException.class)
173 public void testNewSchemaWithNullUrl() throws SAXException {
174 sf.newSchema((URL) null);
175 }
176
177
178 @Test
179 public void testErrorHandler() {
180 SchemaFactory sf = newSchemaFactory();
181 assertNull(sf.getErrorHandler(), "When SchemaFactory is created, initially ErrorHandler should not be set.");
182
183 ErrorHandler handler = new MyErrorHandler();
184 sf.setErrorHandler(handler);
185 assertSame(sf.getErrorHandler(), handler);
186
187 sf.setErrorHandler(null);
188 assertNull(sf.getErrorHandler());
189 }
190
191 @Test(expectedExceptions = SAXNotRecognizedException.class)
192 public void testGetUnrecognizedProperty() throws SAXNotRecognizedException, SAXNotSupportedException {
193 SchemaFactory sf = newSchemaFactory();
194 sf.getProperty(UNRECOGNIZED_NAME);
195
196 }
197
198 @Test(expectedExceptions = SAXNotRecognizedException.class)
199 public void testSetUnrecognizedProperty() throws SAXNotRecognizedException, SAXNotSupportedException {
200 SchemaFactory sf = newSchemaFactory();
201 sf.setProperty(UNRECOGNIZED_NAME, "test");
202 }
203
204 @Test(expectedExceptions = NullPointerException.class)
205 public void testGetNullProperty() throws SAXNotRecognizedException, SAXNotSupportedException {
206 SchemaFactory sf = newSchemaFactory();
207 assertNotNull(sf);
208 sf.getProperty(null);
209
210 }
211
212 @Test(expectedExceptions = NullPointerException.class)
213 public void testSetNullProperty() throws SAXNotRecognizedException, SAXNotSupportedException {
214 SchemaFactory sf = newSchemaFactory();
215 assertNotNull(sf);
216 sf.setProperty(null, "test");
217 }
218
219 @Test(expectedExceptions = SAXNotRecognizedException.class)
220 public void testGetUnrecognizedFeature() throws SAXNotRecognizedException, SAXNotSupportedException {
221 SchemaFactory sf = newSchemaFactory();
222 sf.getFeature(UNRECOGNIZED_NAME);
223
224 }
225
226 @Test(expectedExceptions = SAXNotRecognizedException.class)
227 public void testSetUnrecognizedFeature() throws SAXNotRecognizedException, SAXNotSupportedException {
228 SchemaFactory sf = newSchemaFactory();
229 sf.setFeature(UNRECOGNIZED_NAME, true);
230 }
231
232 @Test(expectedExceptions = NullPointerException.class)
233 public void testGetNullFeature() throws SAXNotRecognizedException, SAXNotSupportedException {
234 SchemaFactory sf = newSchemaFactory();
235 assertNotNull(sf);
236 sf.getFeature(null);
237
238 }
239
240 @Test(expectedExceptions = NullPointerException.class)
241 public void testSetNullFeature() throws SAXNotRecognizedException, SAXNotSupportedException {
242 SchemaFactory sf = newSchemaFactory();
243 assertNotNull(sf);
244 sf.setFeature(null, true);
245 }
246
247 @Test(expectedExceptions = IllegalArgumentException.class)
248 public void testInvalidSchemaLanguage() {
249 final String INVALID_SCHEMA_LANGUAGE = "http://relaxng.org/ns/structure/1.0";
250 SchemaFactory.newInstance(INVALID_SCHEMA_LANGUAGE);
251 }
252
253 @Test(expectedExceptions = NullPointerException.class)
254 public void testNullSchemaLanguage() {
255 SchemaFactory.newInstance(null);
256 }
257
258 private void validate(Schema schema) throws SAXException, IOException {
259 schema.newValidator().validate(new StreamSource(new ByteArrayInputStream(xml)));
260 }
261 private InputStream newInputStream(byte[] xsd) {
262 return new ByteArrayInputStream(xsd);
263 }
264
265 private Source streamSource(byte[] xsd) {
266 return new StreamSource(newInputStream(xsd));
267 }
268
269 private Source nullStreamSource() {
270 return new StreamSource((InputStream) null);
271 }
272
273 private Source saxSource(byte[] xsd) {
274 return new SAXSource(new InputSource(newInputStream(xsd)));
275 }
276
277 private Source nullSaxSource() {
278 return new SAXSource(new InputSource((InputStream) null));
279 }
280
281 private Source domSource(Document xsdDoc) {
282 return new DOMSource(xsdDoc);
283 }
284
285 private SchemaFactory newSchemaFactory() {
286 return SchemaFactory.newInstance(W3C_XML_SCHEMA_NS_URI);
287 }
288
289 private static final String UNRECOGNIZED_NAME = "http://xml.org/sax/features/namespace-prefixes";
290
291 private SchemaFactory sf;
292 private byte[] xsd1;
293 private byte[] xsd2;
294 private Document xsdDoc1;
295 private Document xsdDoc2;
296 private byte[] xml;
297 }