| /* |
| * 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.org.xml.sax.helpers; |
| |
| import java.io.IOException; |
| |
| import junit.framework.TestCase; |
| |
| import org.xml.sax.AttributeList; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.ContentHandler; |
| import org.xml.sax.DTDHandler; |
| import org.xml.sax.EntityResolver; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.Locator; |
| import org.xml.sax.Parser; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXNotRecognizedException; |
| import org.xml.sax.SAXNotSupportedException; |
| import org.xml.sax.helpers.AttributeListImpl; |
| import org.xml.sax.helpers.LocatorImpl; |
| import org.xml.sax.helpers.ParserAdapter; |
| |
| import tests.api.org.xml.sax.support.MethodLogger; |
| import tests.api.org.xml.sax.support.MockHandler; |
| import tests.api.org.xml.sax.support.MockParser; |
| import tests.api.org.xml.sax.support.MockResolver; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargets; |
| import tests.util.TestEnvironment; |
| |
| @SuppressWarnings("deprecation") |
| @TestTargetClass(ParserAdapter.class) |
| public class ParserAdapterTest extends TestCase { |
| |
| // Note: In many cases we can only test that delegation works |
| // properly. The rest is outside the scope of the specification. |
| |
| private final static String FEATURES = "http://xml.org/sax/features/"; |
| |
| private final static String NAMESPACES = FEATURES + "namespaces"; |
| |
| private final static String NAMESPACE_PREFIXES = FEATURES |
| + "namespace-prefixes"; |
| |
| private final static String XMLNS_URIs = FEATURES + "xmlns-uris"; |
| |
| private MethodLogger logger = new MethodLogger(); |
| |
| private MockHandler handler = new MockHandler(logger); |
| |
| private Parser parser = new MockParser(logger); |
| |
| private ParserAdapter adapter = new ParserAdapter(parser); |
| |
| private void assertEquals(Object[] a, Object[] b) { |
| assertEquals(a.length, b.length); |
| |
| for (int i = 0; i < a.length; i++) { |
| assertEquals("Element #" + i + " must be equal", a[i], b[i]); |
| } |
| } |
| |
| @Override |
| public void setUp() { |
| TestEnvironment.reset(); |
| adapter.setContentHandler(handler); |
| adapter.setDTDHandler(handler); |
| adapter.setErrorHandler(handler); |
| } |
| |
| @Override protected void tearDown() throws Exception { |
| TestEnvironment.reset(); |
| super.tearDown(); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "ParserAdapter", |
| args = { } |
| ) |
| public void testParserAdapter() { |
| System.setProperty("org.xml.sax.parser", |
| "tests.api.org.xml.sax.support.DoNothingParser"); |
| |
| try { |
| new ParserAdapter(); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "ParserAdapter", |
| args = { Parser.class } |
| ) |
| public void testParserAdapterParser() { |
| // Ordinary case |
| @SuppressWarnings("unused") |
| ParserAdapter adapter = new ParserAdapter(parser); |
| |
| // Null case |
| try { |
| adapter = new ParserAdapter(null); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| // Expected |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getFeature", |
| args = { String.class } |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setFeature", |
| args = { String.class, boolean.class } |
| ) |
| }) |
| public void testGetSetFeature() { |
| String[] features = new String[] { NAMESPACES, NAMESPACE_PREFIXES, |
| XMLNS_URIs }; |
| |
| for (String s: features) { |
| try { |
| adapter.setFeature(s, true); |
| assertEquals(true, adapter.getFeature(s)); |
| |
| adapter.setFeature(s, false); |
| assertEquals(false, adapter.getFeature(s)); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| try { |
| adapter.setFeature("http://argle.bargle", true); |
| fail("SAXNotRecognizedException expected"); |
| } catch (SAXNotRecognizedException e) { |
| // Expected |
| } catch (SAXNotSupportedException 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 testGetSetProperty() { |
| try { |
| adapter.setProperty("http://argle.bargle", ":)"); |
| fail("SAXNotRecognizedException expected"); |
| } catch (SAXNotRecognizedException e) { |
| // Expected |
| } catch (SAXNotSupportedException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| try { |
| adapter.getProperty("http://argle.bargle"); |
| fail("SAXNotRecognizedException expected"); |
| } catch (SAXNotRecognizedException e) { |
| // Expected |
| } catch (SAXNotSupportedException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getEntityResolver", |
| args = { } |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setEntityResolver", |
| args = { EntityResolver.class } |
| ) |
| }) |
| public void testGetSetEntityResolver() { |
| EntityResolver resolver = new MockResolver(); |
| |
| adapter.setEntityResolver(resolver); |
| assertEquals(resolver, adapter.getEntityResolver()); |
| |
| adapter.setEntityResolver(null); |
| assertEquals(null, adapter.getEntityResolver()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getDTDHandler", |
| args = { } |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setDTDHandler", |
| args = { DTDHandler.class } |
| ) |
| }) |
| public void testGetSetDTDHandler() { |
| adapter.setDTDHandler(null); |
| assertEquals(null, adapter.getDTDHandler()); |
| |
| adapter.setDTDHandler(handler); |
| assertEquals(handler, adapter.getDTDHandler()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getContentHandler", |
| args = { } |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setContentHandler", |
| args = { ContentHandler.class } |
| ) |
| }) |
| public void testGetSetContentHandler() { |
| adapter.setContentHandler(null); |
| assertEquals(null, adapter.getContentHandler()); |
| |
| adapter.setContentHandler(handler); |
| assertEquals(handler, adapter.getContentHandler()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getErrorHandler", |
| args = { } |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setErrorHandler", |
| args = { ErrorHandler.class } |
| ) |
| }) |
| public void testGetSetErrorHandler() { |
| adapter.setErrorHandler(null); |
| assertEquals(null, adapter.getErrorHandler()); |
| |
| adapter.setErrorHandler(handler); |
| assertEquals(handler, adapter.getErrorHandler()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "parse", |
| args = { String.class } |
| ) |
| public void testParseString() { |
| try { |
| adapter.parse("foo"); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } catch (IOException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| // The SAX RI creates an InputSource itself and then delegates to the |
| // "other" parse method. |
| assertEquals("parse", logger.getMethod()); |
| assertEquals(InputSource.class, logger.getArgs()[0].getClass()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "parse", |
| args = { InputSource.class } |
| ) |
| public void testParseInputSource() { |
| InputSource source = new InputSource("foo"); |
| |
| try { |
| adapter.parse(source); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } catch (IOException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals("parse", logger.getMethod()); |
| assertEquals(new Object[] { source }, logger.getArgs()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setDocumentLocator", |
| args = { Locator.class } |
| ) |
| public void testSetDocumentLocator() { |
| Locator l = new LocatorImpl(); |
| |
| adapter.setDocumentLocator(l); |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("setDocumentLocator", logger.getMethod()); |
| assertEquals(new Object[] { l }, logger.getArgs()); |
| |
| adapter.setDocumentLocator(null); |
| |
| assertEquals(logger.size(), 2); |
| assertEquals("setDocumentLocator", logger.getMethod()); |
| assertEquals(new Object[] { null }, logger.getArgs()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "startDocument", |
| args = { } |
| ) |
| public void testStartDocument() { |
| try { |
| adapter.startDocument(); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("startDocument", logger.getMethod()); |
| assertEquals(new Object[] {}, logger.getArgs()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "endDocument", |
| args = { } |
| ) |
| public void testEndDocument() { |
| try { |
| adapter.endDocument(); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("endDocument", logger.getMethod()); |
| assertEquals(new Object[] {}, logger.getArgs()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "startElement", |
| args = { String.class, AttributeList.class } |
| ) |
| public void testStartElement() { |
| AttributeListImpl atts = new AttributeListImpl(); |
| atts.addAttribute("john:doe", "int", "42"); |
| |
| try { |
| adapter.startDocument(); |
| adapter.startElement("foo:bar", atts); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals("startElement", logger.getMethod()); |
| assertEquals("", logger.getArgs()[0]); |
| assertEquals("", logger.getArgs()[1]); |
| assertEquals("foo:bar", logger.getArgs()[2]); |
| assertEquals("john:doe", ((Attributes)logger.getArgs()[3]).getQName(0)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "endElement", |
| args = { String.class } |
| ) |
| public void testEndElement() { |
| AttributeListImpl atts = new AttributeListImpl(); |
| atts.addAttribute("john:doe", "int", "42"); |
| |
| try { |
| adapter.startDocument(); |
| adapter.startElement("foo:bar", atts); |
| adapter.endElement("foo:bar"); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals("endElement", logger.getMethod()); |
| assertEquals(new String[] { "", "", "foo:bar" }, logger.getArgs()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "characters", |
| args = { char[].class, int.class, int.class } |
| ) |
| public void testCharacters() { |
| char[] ch = "Android".toCharArray(); |
| |
| try { |
| adapter.characters(ch, 2, 5); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("characters", logger.getMethod()); |
| assertEquals(new Object[] { ch, 2, 5 }, logger.getArgs()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "ignorableWhitespace", |
| args = { char[].class, int.class, int.class } |
| ) |
| public void testIgnorableWhitespace() { |
| char[] ch = " ".toCharArray(); |
| |
| try { |
| adapter.ignorableWhitespace(ch, 0, 5); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("ignorableWhitespace", logger.getMethod()); |
| assertEquals(new Object[] { ch, 0, 5 }, logger.getArgs()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "processingInstruction", |
| args = { String.class, String.class } |
| ) |
| public void testProcessingInstruction() { |
| try { |
| adapter.processingInstruction("foo", "bar"); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("processingInstruction", logger.getMethod()); |
| assertEquals(new Object[] { "foo" , "bar" }, logger.getArgs()); |
| } |
| |
| } |