| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package tests.api.javax.xml.parsers; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.OutputStream; |
| import java.util.HashMap; |
| import java.util.Vector; |
| |
| import javax.xml.parsers.SAXParser; |
| import javax.xml.parsers.SAXParserFactory; |
| |
| import junit.framework.TestCase; |
| |
| import org.xml.sax.HandlerBase; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.Parser; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXNotRecognizedException; |
| import org.xml.sax.SAXNotSupportedException; |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.ext.LexicalHandler; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| import tests.api.javax.xml.parsers.SAXParserTestSupport.MyDefaultHandler; |
| import tests.api.javax.xml.parsers.SAXParserTestSupport.MyHandler; |
| import tests.api.org.xml.sax.support.BrokenInputStream; |
| import tests.api.org.xml.sax.support.MethodLogger; |
| import tests.api.org.xml.sax.support.MockHandler; |
| import tests.support.resource.Support_Resources; |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargets; |
| |
| @SuppressWarnings("deprecation") |
| @TestTargetClass(SAXParser.class) |
| public class SAXParserTest extends TestCase { |
| |
| private class MockSAXParser extends SAXParser { |
| public MockSAXParser() { |
| super(); |
| } |
| |
| /* |
| * @see javax.xml.parsers.SAXParser#getParser() |
| */ |
| @Override |
| public Parser getParser() throws SAXException { |
| // it is a fake |
| return null; |
| } |
| |
| /* |
| * @see javax.xml.parsers.SAXParser#getProperty(java.lang.String) |
| */ |
| @Override |
| public Object getProperty(String name) throws SAXNotRecognizedException, |
| SAXNotSupportedException { |
| // it is a fake |
| return null; |
| } |
| |
| /* |
| * @see javax.xml.parsers.SAXParser#getXMLReader() |
| */ |
| @Override |
| public XMLReader getXMLReader() throws SAXException { |
| // it is a fake |
| return null; |
| } |
| |
| /* |
| * @see javax.xml.parsers.SAXParser#isNamespaceAware() |
| */ |
| @Override |
| public boolean isNamespaceAware() { |
| // it is a fake |
| return false; |
| } |
| |
| /* |
| * @see javax.xml.parsers.SAXParser#isValidating() |
| */ |
| @Override |
| public boolean isValidating() { |
| // it is a fake |
| return false; |
| } |
| |
| /* |
| * @see javax.xml.parsers.SAXParser#setProperty(java.lang.String, |
| * java.lang.Object) |
| */ |
| @Override |
| public void setProperty(String name, Object value) throws |
| SAXNotRecognizedException, SAXNotSupportedException { |
| // it is a fake |
| } |
| } |
| |
| private static final String LEXICAL_HANDLER_PROPERTY |
| = "http://xml.org/sax/properties/lexical-handler"; |
| |
| SAXParserFactory spf; |
| |
| SAXParser parser; |
| |
| static HashMap<String, String> ns; |
| |
| static Vector<String> el; |
| |
| static HashMap<String, String> attr; |
| |
| SAXParserTestSupport sp = new SAXParserTestSupport(); |
| |
| File [] list_wf; |
| File [] list_nwf; |
| File [] list_out_dh; |
| File [] list_out_hb; |
| |
| boolean validating = false; |
| |
| private InputStream getResource(String name) { |
| return this.getClass().getResourceAsStream(name); |
| } |
| |
| public void initFiles() throws Exception { |
| // we differntiate between a validating and a non validating parser |
| try { |
| SAXParser parser = SAXParserFactory.newInstance().newSAXParser(); |
| validating = parser.isValidating(); |
| } catch (Exception e) { |
| fail("could not obtain a SAXParser"); |
| } |
| |
| String tmpPath = System.getProperty("java.io.tmpdir"); |
| |
| // nwf = not well formed, wf = well formed |
| list_wf = new File[] {new File(tmpPath + "/" + |
| SAXParserTestSupport.XML_WF + "staff.xml")}; |
| list_nwf = new File[] {new File(tmpPath + "/" + |
| SAXParserTestSupport.XML_NWF + "staff.xml")}; |
| list_out_dh = new File[] {new File(tmpPath + "/" + |
| SAXParserTestSupport.XML_WF_OUT_DH + "staff.out")}; |
| list_out_hb = new File[] {new File(tmpPath + "/" + |
| SAXParserTestSupport.XML_WF_OUT_HB + "staff.out")}; |
| |
| list_wf[0].deleteOnExit(); |
| list_nwf[0].deleteOnExit(); |
| list_out_hb[0].deleteOnExit(); |
| list_out_dh[0].deleteOnExit(); |
| |
| |
| Support_Resources.copyLocalFileto(list_wf[0], |
| getResource(SAXParserTestSupport.XML_WF + "staff.xml")); |
| Support_Resources.copyLocalFileto(new File( |
| tmpPath + "/" + SAXParserTestSupport.XML_WF + "staff.dtd"), |
| getResource(SAXParserTestSupport.XML_WF + "staff.dtd")); |
| |
| Support_Resources.copyLocalFileto(list_nwf[0], |
| getResource(SAXParserTestSupport.XML_NWF + "staff.xml")); |
| Support_Resources.copyLocalFileto(new File( |
| tmpPath + "/" + SAXParserTestSupport.XML_NWF + "staff.dtd"), |
| getResource(SAXParserTestSupport.XML_NWF + "staff.dtd")); |
| |
| Support_Resources.copyLocalFileto(list_out_dh[0], |
| getResource(SAXParserTestSupport.XML_WF_OUT_DH + "staff.out")); |
| Support_Resources.copyLocalFileto(list_out_hb[0], |
| getResource(SAXParserTestSupport.XML_WF_OUT_HB + "staff.out")); |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| spf = SAXParserFactory.newInstance(); |
| parser = spf.newSAXParser(); |
| assertNotNull(parser); |
| |
| ns = new HashMap<String, String>(); |
| attr = new HashMap<String, String>(); |
| el = new Vector<String>(); |
| initFiles(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| } |
| |
| // public static void main(String[] args) throws Exception { |
| // SAXParserTest st = new SAXParserTest(); |
| // st.setUp(); |
| // st.generateDataFromReferenceImpl(); |
| // |
| // } |
| // |
| // private void generateDataFromReferenceImpl() { |
| // try { |
| // for(int i = 0; i < list_wf.length; i++) { |
| // MyDefaultHandler dh = new MyDefaultHandler(); |
| // InputStream is = new FileInputStream(list_wf[i]); |
| // parser.parse(is, dh, ParsingSupport.XML_SYSTEM_ID); |
| // HashMap refHm = dh.createData(); |
| // |
| // StringBuilder sb = new StringBuilder(); |
| // for (int j = 0; j < ParsingSupport.KEYS.length; j++) { |
| // String key = ParsingSupport.KEYS[j]; |
| // sb.append(refHm.get(key)).append( |
| // ParsingSupport.SEPARATOR_DATA); |
| // } |
| // FileWriter fw = new FileWriter("/tmp/build_dh"+i+".out"); |
| // fw.append(sb.toString()); |
| // fw.close(); |
| // } |
| // |
| // for(int i = 0; i < list_nwf.length; i++) { |
| // MyHandler hb = new MyHandler(); |
| // InputStream is = new FileInputStream(list_wf[i]); |
| // parser.parse(is, hb, ParsingSupport.XML_SYSTEM_ID); |
| // HashMap refHm = hb.createData(); |
| // |
| // StringBuilder sb = new StringBuilder(); |
| // for (int j = 0; j < ParsingSupport.KEYS.length; j++) { |
| // String key = ParsingSupport.KEYS[j]; |
| // sb.append(refHm.get(key)).append( |
| // ParsingSupport.SEPARATOR_DATA); |
| // } |
| // FileWriter fw = new FileWriter("/tmp/build_hb"+i+".out"); |
| // fw.append(sb.toString()); |
| // fw.close(); |
| // } |
| // |
| // |
| // } catch (Exception e) { |
| // e.printStackTrace(); |
| // } |
| // } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "SAXParser", |
| args = {} |
| ) |
| public void testSAXParser() { |
| try { |
| new MockSAXParser(); |
| } catch (Exception e) { |
| fail("unexpected exception " + e.toString()); |
| } |
| } |
| |
| /** |
| * @tests javax.xml.parser.SAXParser#getSchema(). |
| * TODO getSchema() IS NOT SUPPORTED |
| */ |
| /* public void test_getSchema() { |
| assertNull(parser.getSchema()); |
| SchemaFactory sf = |
| SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); |
| try { |
| Schema schema = sf.newSchema(); |
| spf.setSchema(schema); |
| assertNotNull(spf.newSAXParser().getSchema()); |
| } catch (ParserConfigurationException pce) { |
| fail("Unexpected ParserConfigurationException " + pce.toString()); |
| } catch (SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| */ |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isNamespaceAware", |
| args = {} |
| ) |
| public void testIsNamespaceAware() { |
| try { |
| spf.setNamespaceAware(true); |
| assertTrue(spf.newSAXParser().isNamespaceAware()); |
| spf.setNamespaceAware(false); |
| assertFalse(spf.newSAXParser().isNamespaceAware()); |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "No validating parser in Android, hence not tested", |
| method = "isValidating", |
| args = {} |
| ) |
| public void testIsValidating() { |
| try { |
| spf.setValidating(false); |
| assertFalse(spf.newSAXParser().isValidating()); |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "No XInclude-aware parser in Android, hence not tested", |
| method = "isXIncludeAware", |
| args = {} |
| ) |
| public void testIsXIncludeAware() { |
| try { |
| spf.setXIncludeAware(false); |
| assertFalse(spf.newSAXParser().isXIncludeAware()); |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| /** |
| * @test javax.xml.parsers.SAXParser#parse(java.io.File, |
| * org.xml.sax.helpers.DefaultHandler) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Doesn't verify positive functionality properly; not all exceptions are verified.", |
| method = "parse", |
| args = {java.io.File.class, org.xml.sax.helpers.DefaultHandler.class} |
| ) |
| public void test_parseLjava_io_FileLorg_xml_sax_helpers_DefaultHandler() |
| throws Exception { |
| |
| for(int i = 0; i < list_wf.length; i++) { |
| HashMap<String, String> hm = |
| new SAXParserTestSupport().readFile(list_out_dh[i].getPath()); |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse(list_wf[i], dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, dh.createData())); |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse(list_nwf[i], dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } |
| } |
| |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse((File) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } |
| |
| try { |
| parser.parse(list_wf[0], (DefaultHandler) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Sufficient while XML parser situation is still unclear", |
| method = "parse", |
| args = {java.io.File.class, org.xml.sax.HandlerBase.class} |
| ) |
| public void testParseFileHandlerBase() { |
| for(int i = 0; i < list_wf.length; i++) { |
| try { |
| HashMap<String, String> hm = sp.readFile( |
| list_out_hb[i].getPath()); |
| MyHandler dh = new MyHandler(); |
| parser.parse(list_wf[i], dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, |
| dh.createData())); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch (SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyHandler dh = new MyHandler(); |
| parser.parse(list_nwf[i], dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } |
| } |
| |
| try { |
| MyHandler dh = new MyHandler(); |
| parser.parse((File) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| try { |
| parser.parse(list_wf[0], (HandlerBase) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| /** |
| * @test javax.xml.parsers.SAXParser#parse(org.xml.sax.InputSource, |
| * org.xml.sax.helpers.DefaultHandler) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Doesn't verify IOException.", |
| method = "parse", |
| args = {org.xml.sax.InputSource.class, org.xml.sax.helpers.DefaultHandler.class} |
| ) |
| public void test_parseLorg_xml_sax_InputSourceLorg_xml_sax_helpers_DefaultHandler() |
| throws Exception { |
| |
| for(int i = 0; i < list_wf.length; i++) { |
| |
| HashMap<String, String> hm = new SAXParserTestSupport().readFile( |
| list_out_dh[i].getPath()); |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| InputSource is = new InputSource(new FileInputStream(list_wf[i])); |
| parser.parse(is, dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, dh.createData())); |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| InputSource is = new InputSource( |
| new FileInputStream(list_nwf[i])); |
| parser.parse(is, dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } |
| } |
| |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse((InputSource) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } |
| |
| try { |
| InputSource is = new InputSource(new FileInputStream(list_wf[0])); |
| parser.parse(is, (DefaultHandler) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } |
| |
| try { |
| InputSource is = new InputSource(new BrokenInputStream(new FileInputStream(list_wf[0]), 10)); |
| parser.parse(is, (DefaultHandler) null); |
| fail("IOException expected"); |
| } catch(IOException e) { |
| // Expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Sufficient while XML parser situation is still unclear", |
| method = "parse", |
| args = {org.xml.sax.InputSource.class, org.xml.sax.HandlerBase.class} |
| ) |
| public void testParseInputSourceHandlerBase() { |
| for(int i = 0; i < list_wf.length; i++) { |
| try { |
| HashMap<String, String> hm = sp.readFile( |
| list_out_hb[i].getPath()); |
| MyHandler dh = new MyHandler(); |
| InputSource is = new InputSource(new FileInputStream(list_wf[i])); |
| parser.parse(is, dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, |
| dh.createData())); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch (SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyHandler dh = new MyHandler(); |
| InputSource is = new InputSource(new FileInputStream(list_nwf[i])); |
| parser.parse(is, dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } |
| } |
| |
| try { |
| MyHandler dh = new MyHandler(); |
| parser.parse((InputSource) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| try { |
| InputSource is = new InputSource(new FileInputStream(list_wf[0])); |
| parser.parse(is, (HandlerBase) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| // Reader case |
| try { |
| InputSource is = new InputSource(new InputStreamReader( |
| new FileInputStream(list_wf[0]))); |
| parser.parse(is, (HandlerBase) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| // SystemID case |
| try { |
| InputSource is = new InputSource(list_wf[0].toURI().toString()); |
| parser.parse(is, (HandlerBase) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| // Inject IOException |
| try { |
| InputStream is = new BrokenInputStream( |
| new FileInputStream(list_wf[0]), 10); |
| parser.parse(is, (HandlerBase) null, |
| SAXParserTestSupport.XML_SYSTEM_ID); |
| fail("IOException expected"); |
| } catch(IOException e) { |
| // Expected |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| /** |
| * @test javax.xml.parsers.SAXParser#parse(java.io.InputStream, |
| * org.xml.sax.helpers.DefaultHandler) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Doesn't verify IOException.", |
| method = "parse", |
| args = {java.io.InputStream.class, org.xml.sax.helpers.DefaultHandler.class} |
| ) |
| public void test_parseLjava_io_InputStreamLorg_xml_sax_helpers_DefaultHandler() |
| throws Exception { |
| |
| for(int i = 0; i < list_wf.length; i++) { |
| |
| HashMap<String, String> hm = new SAXParserTestSupport().readFile( |
| list_out_dh[i].getPath()); |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| InputStream is = new FileInputStream(list_wf[i]); |
| parser.parse(is, dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, dh.createData())); |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| InputStream is = new FileInputStream(list_nwf[i]); |
| parser.parse(is, dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } |
| } |
| |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse((InputStream) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } |
| |
| try { |
| InputStream is = new FileInputStream(list_wf[0]); |
| parser.parse(is, (DefaultHandler) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } |
| } |
| |
| /** |
| * @test javax.xml.parsers.SAXParser#parse(java.io.InputStream, |
| * org.xml.sax.helpers.DefaultHandler, java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Doesn't verify IOException.", |
| method = "parse", |
| args = {java.io.InputStream.class, org.xml.sax.helpers.DefaultHandler.class, java.lang.String.class} |
| ) |
| @KnownFailure("We supply optional qnames, but this test doesn't expect them") |
| public void test_parseLjava_io_InputStreamLorg_xml_sax_helpers_DefaultHandlerLjava_lang_String() { |
| for(int i = 0; i < list_wf.length; i++) { |
| try { |
| HashMap<String, String> hm = sp.readFile( |
| list_out_hb[i].getPath()); |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| InputStream is = new FileInputStream(list_wf[i]); |
| parser.parse(is, dh, SAXParserTestSupport.XML_SYSTEM_ID); |
| assertEquals(hm, dh.createData()); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch (SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| InputStream is = new FileInputStream(list_nwf[i]); |
| parser.parse(is, dh, SAXParserTestSupport.XML_SYSTEM_ID); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } |
| } |
| |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse((InputStream) null, dh, |
| SAXParserTestSupport.XML_SYSTEM_ID); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| try { |
| InputStream is = new FileInputStream(list_wf[0]); |
| parser.parse(is, (DefaultHandler) null, |
| SAXParserTestSupport.XML_SYSTEM_ID); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| // |
| // for(int i = 0; i < list_wf.length; i++) { |
| // |
| // HashMap<String, String> hm = new SAXParserTestSupport().readFile( |
| // list_out_dh[i].getPath()); |
| // MyDefaultHandler dh = new MyDefaultHandler(); |
| // InputStream is = new FileInputStream(list_wf[i]); |
| // parser.parse(is, dh, SAXParserTestSupport.XML_SYSTEM_ID); |
| // assertTrue(SAXParserTestSupport.equalsMaps(hm, dh.createData())); |
| // } |
| // |
| // for(int i = 0; i < list_nwf.length; i++) { |
| // try { |
| // MyDefaultHandler dh = new MyDefaultHandler(); |
| // InputStream is = new FileInputStream(list_nwf[i]); |
| // parser.parse(is, dh, SAXParserTestSupport.XML_SYSTEM_ID); |
| // fail("SAXException is not thrown"); |
| // } catch(org.xml.sax.SAXException se) { |
| // //expected |
| // } |
| // } |
| // |
| // try { |
| // MyDefaultHandler dh = new MyDefaultHandler(); |
| // parser.parse((InputStream) null, dh, |
| // SAXParserTestSupport.XML_SYSTEM_ID); |
| // fail("java.lang.IllegalArgumentException is not thrown"); |
| // } catch(java.lang.IllegalArgumentException iae) { |
| // //expected |
| // } |
| // |
| // try { |
| // InputStream is = new FileInputStream(list_wf[0]); |
| // parser.parse(is, (DefaultHandler) null, |
| // SAXParserTestSupport.XML_SYSTEM_ID); |
| // } catch(java.lang.IllegalArgumentException iae) { |
| // fail("java.lang.IllegalArgumentException is thrown"); |
| // } |
| // |
| // // TODO commented out since our parser is nonvalidating and thus never |
| // // tries to load staff.dtd in "/" ... and therefore never can fail with |
| // // an IOException |
| // /*try { |
| // MyDefaultHandler dh = new MyDefaultHandler(); |
| // InputStream is = new FileInputStream(list_wf[0]); |
| // parser.parse(is, dh, "/"); |
| // fail("Expected IOException was not thrown"); |
| // } catch(IOException ioe) { |
| // // expected |
| // }*/ |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Sufficient while XML parser situation is still unclear", |
| method = "parse", |
| args = {java.io.InputStream.class, org.xml.sax.HandlerBase.class} |
| ) |
| public void testParseInputStreamHandlerBase() { |
| for(int i = 0; i < list_wf.length; i++) { |
| try { |
| HashMap<String, String> hm = sp.readFile( |
| list_out_hb[i].getPath()); |
| MyHandler dh = new MyHandler(); |
| InputStream is = new FileInputStream(list_wf[i]); |
| parser.parse(is, dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, |
| dh.createData())); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch (SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyHandler dh = new MyHandler(); |
| InputStream is = new FileInputStream(list_nwf[i]); |
| parser.parse(is, dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } |
| } |
| |
| try { |
| MyHandler dh = new MyHandler(); |
| parser.parse((InputStream) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| try { |
| InputStream is = new FileInputStream(list_wf[0]); |
| parser.parse(is, (HandlerBase) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| // Inject IOException |
| try { |
| InputStream is = new BrokenInputStream( |
| new FileInputStream(list_wf[0]), 10); |
| parser.parse(is, (HandlerBase) null); |
| fail("IOException expected"); |
| } catch(IOException e) { |
| // Expected |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Sufficient while XML parser situation is still unclear", |
| method = "parse", |
| args = {java.io.InputStream.class, org.xml.sax.HandlerBase.class, java.lang.String.class} |
| ) |
| public void testParseInputStreamHandlerBaseString() { |
| for(int i = 0; i < list_wf.length; i++) { |
| try { |
| HashMap<String, String> hm = sp.readFile( |
| list_out_hb[i].getPath()); |
| MyHandler dh = new MyHandler(); |
| InputStream is = new FileInputStream(list_wf[i]); |
| parser.parse(is, dh, SAXParserTestSupport.XML_SYSTEM_ID); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, |
| dh.createData())); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch (SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyHandler dh = new MyHandler(); |
| InputStream is = new FileInputStream(list_nwf[i]); |
| parser.parse(is, dh, SAXParserTestSupport.XML_SYSTEM_ID); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } |
| } |
| |
| try { |
| MyHandler dh = new MyHandler(); |
| parser.parse((InputStream) null, dh, |
| SAXParserTestSupport.XML_SYSTEM_ID); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| try { |
| InputStream is = new FileInputStream(list_wf[0]); |
| parser.parse(is, (HandlerBase) null, |
| SAXParserTestSupport.XML_SYSTEM_ID); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| // Inject IOException |
| try { |
| InputStream is = new BrokenInputStream( |
| new FileInputStream(list_wf[0]), 10); |
| parser.parse(is, (HandlerBase) null, |
| SAXParserTestSupport.XML_SYSTEM_ID); |
| fail("IOException expected"); |
| } catch(IOException e) { |
| // Expected |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| /** |
| * @test javax.xml.parsers.SAXParser#parse(java.lang.String, |
| * org.xml.sax.helpers.DefaultHandler) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Doesn't verify IOException.", |
| method = "parse", |
| args = {java.lang.String.class, org.xml.sax.helpers.DefaultHandler.class} |
| ) |
| public void test_parseLjava_lang_StringLorg_xml_sax_helpers_DefaultHandler() |
| throws Exception { |
| |
| for(int i = 0; i < list_wf.length; i++) { |
| |
| HashMap<String, String> hm = new SAXParserTestSupport().readFile( |
| list_out_dh[i].getPath()); |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse(list_wf[i].toURI().toString(), dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, dh.createData())); |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse(list_nwf[i].toURI().toString(), dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } |
| } |
| |
| try { |
| MyDefaultHandler dh = new MyDefaultHandler(); |
| parser.parse((String) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } |
| |
| try { |
| parser.parse(list_wf[0].toURI().toString(), (DefaultHandler) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Sufficient while XML parser situation is still unclear", |
| method = "parse", |
| args = {java.lang.String.class, org.xml.sax.HandlerBase.class} |
| ) |
| public void testParseStringHandlerBase() { |
| for(int i = 0; i < list_wf.length; i++) { |
| try { |
| HashMap<String, String> hm = sp.readFile( |
| list_out_hb[i].getPath()); |
| MyHandler dh = new MyHandler(); |
| parser.parse(list_wf[i].toURI().toString(), dh); |
| assertTrue(SAXParserTestSupport.equalsMaps(hm, |
| dh.createData())); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch (SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| for(int i = 0; i < list_nwf.length; i++) { |
| try { |
| MyHandler dh = new MyHandler(); |
| parser.parse(list_nwf[i].toURI().toString(), dh); |
| fail("SAXException is not thrown"); |
| } catch(org.xml.sax.SAXException se) { |
| //expected |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } |
| } |
| |
| try { |
| MyHandler dh = new MyHandler(); |
| parser.parse((String) null, dh); |
| fail("java.lang.IllegalArgumentException is not thrown"); |
| } catch(java.lang.IllegalArgumentException iae) { |
| //expected |
| } catch (IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| |
| try { |
| parser.parse(list_wf[0].toURI().toString(), (HandlerBase) null); |
| } catch(java.lang.IllegalArgumentException iae) { |
| fail("java.lang.IllegalArgumentException is thrown"); |
| } catch (FileNotFoundException fne) { |
| fail("Unexpected FileNotFoundException " + fne.toString()); |
| } catch(IOException ioe) { |
| fail("Unexpected IOException " + ioe.toString()); |
| } catch(SAXException sax) { |
| fail("Unexpected SAXException " + sax.toString()); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "reset", |
| args = { } |
| ) |
| public void testReset() { |
| try { |
| spf = SAXParserFactory.newInstance(); |
| parser = spf.newSAXParser(); |
| |
| parser.setProperty(LEXICAL_HANDLER_PROPERTY, new MockHandler(new MethodLogger())); |
| parser.reset(); |
| assertEquals(null, parser.getProperty(LEXICAL_HANDLER_PROPERTY)); |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getParser", |
| args = { } |
| ) |
| public void testGetParser() { |
| spf = SAXParserFactory.newInstance(); |
| try { |
| Parser parser = spf.newSAXParser().getParser(); |
| assertNotNull(parser); |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getXMLReader", |
| args = { } |
| ) |
| public void testGetReader() { |
| spf = SAXParserFactory.newInstance(); |
| try { |
| XMLReader reader = spf.newSAXParser().getXMLReader(); |
| assertNotNull(reader); |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getProperty", |
| args = { String.class } |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setProperty", |
| args = { String.class, Object.class } |
| ) |
| }) |
| public void testSetGetProperty() { |
| // Ordinary case |
| String validName = "http://xml.org/sax/properties/lexical-handler"; |
| LexicalHandler validValue = new MockHandler(new MethodLogger()); |
| |
| try { |
| SAXParser parser = spf.newSAXParser(); |
| parser.setProperty(validName, validValue); |
| assertEquals(validValue, parser.getProperty(validName)); |
| |
| parser.setProperty(validName, null); |
| assertEquals(null, parser.getProperty(validName)); |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| // Unsupported property |
| try { |
| SAXParser parser = spf.newSAXParser(); |
| parser.setProperty("foo", "bar"); |
| fail("SAXNotRecognizedException expected"); |
| } catch (SAXNotRecognizedException e) { |
| // Expected |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| try { |
| SAXParser parser = spf.newSAXParser(); |
| parser.getProperty("foo"); |
| fail("SAXNotRecognizedException expected"); |
| } catch (SAXNotRecognizedException e) { |
| // Expected |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| // No name case |
| try { |
| SAXParser parser = spf.newSAXParser(); |
| parser.setProperty(null, "bar"); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| // Expected |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| try { |
| SAXParser parser = spf.newSAXParser(); |
| parser.getProperty(null); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| // Expected |
| } catch (Exception e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| } |