| /* |
| * 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 java.util.Locale; |
| |
| import junit.framework.TestCase; |
| |
| import org.xml.sax.AttributeList; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.DTDHandler; |
| import org.xml.sax.DocumentHandler; |
| import org.xml.sax.EntityResolver; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.helpers.AttributesImpl; |
| import org.xml.sax.helpers.LocatorImpl; |
| import org.xml.sax.helpers.XMLReaderAdapter; |
| |
| import tests.api.org.xml.sax.support.MethodLogger; |
| import tests.api.org.xml.sax.support.MockHandler; |
| import tests.api.org.xml.sax.support.MockReader; |
| import tests.api.org.xml.sax.support.MockResolver; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| |
| @SuppressWarnings("deprecation") |
| @TestTargetClass(XMLReaderAdapter.class) |
| public class XMLReaderAdapterTest extends TestCase { |
| |
| // Note: In many cases we can only test that delegation works |
| // properly. The rest is outside the scope of the specification. |
| |
| private MethodLogger logger = new MethodLogger(); |
| |
| private MockHandler handler = new MockHandler(logger); |
| |
| private XMLReader reader = new MockReader(logger); |
| |
| private XMLReaderAdapter adapter = new XMLReaderAdapter(reader); |
| |
| 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() { |
| adapter.setDocumentHandler(handler); |
| adapter.setDTDHandler(handler); |
| adapter.setErrorHandler(handler); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "XMLReaderAdapter", |
| args = { } |
| ) |
| public void testXMLReaderAdapter() { |
| System.setProperty("org.xml.sax.driver", |
| "tests.api.org.xml.sax.support.DoNothingXMLReader"); |
| |
| try { |
| new XMLReaderAdapter(); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "XMLReaderAdapter", |
| args = { XMLReader.class } |
| ) |
| public void testXMLReaderAdapterXMLReader() { |
| // Ordinary case |
| @SuppressWarnings("unused") |
| XMLReaderAdapter adapter = new XMLReaderAdapter(reader); |
| |
| // Null case |
| try { |
| adapter = new XMLReaderAdapter(null); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| // Expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setLocale", |
| args = { Locale.class } |
| ) |
| public void testSetLocale() { |
| // SAX RI does not support this, hence always expect exception |
| try { |
| adapter.setLocale(Locale.getDefault()); |
| fail("SAXException expected"); |
| } catch (SAXException e) { |
| // Expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setEntityResolver", |
| args = { EntityResolver.class } |
| ) |
| public void testSetEntityResolver() { |
| EntityResolver resolver = new MockResolver(); |
| |
| // Ordinary case |
| adapter.setEntityResolver(resolver); |
| assertEquals(resolver, reader.getEntityResolver()); |
| |
| // null case |
| adapter.setEntityResolver(null); |
| assertEquals(null, reader.getEntityResolver()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setDTDHandler", |
| args = { DTDHandler.class } |
| ) |
| public void testSetDTDHandler() { |
| // Ordinary case |
| assertEquals(handler, reader.getDTDHandler()); |
| |
| // null case |
| adapter.setDTDHandler(null); |
| assertEquals(null, reader.getDTDHandler()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setDocumentHandler", |
| args = { DocumentHandler.class } |
| ) |
| public void testSetDocumentHandler() { |
| // There is no getter for the DocumentHandler, so we can only test |
| // indirectly whether is has been set correctly. |
| try { |
| adapter.startDocument(); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals("startDocument", logger.getMethod()); |
| assertEquals(new Object[] { }, logger.getArgs()); |
| |
| // null case |
| adapter.setDocumentHandler(null); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setErrorHandler", |
| args = { ErrorHandler.class } |
| ) |
| public void testSetErrorHandler() { |
| // Ordinary case |
| assertEquals(handler, reader.getErrorHandler()); |
| |
| // null case |
| adapter.setErrorHandler(null); |
| assertEquals(null, reader.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(0)); |
| assertEquals(InputSource.class, logger.getArgs(0)[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() { |
| // Ordinary case |
| LocatorImpl locator = new LocatorImpl(); |
| adapter.setDocumentLocator(locator); |
| |
| assertEquals("setDocumentLocator", logger.getMethod()); |
| assertEquals(new Object[] { locator }, logger.getArgs()); |
| |
| // null case (for the DocumentHandler itself!) |
| adapter.setDocumentHandler(null); |
| adapter.setDocumentLocator(locator); |
| } |
| |
| @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 = "startPrefixMapping", |
| args = { String.class, String.class } |
| ) |
| public void testStartPrefixMapping() { |
| adapter.startPrefixMapping("foo", "http://some.uri"); |
| assertEquals(logger.size(), 0); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "endPrefixMapping", |
| args = { String.class } |
| ) |
| public void testEndPrefixMapping() { |
| adapter.endPrefixMapping("foo"); |
| assertEquals(logger.size(), 0); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "startElement", |
| args = { String.class, String.class, String.class, Attributes.class } |
| ) |
| public void testStartElement() { |
| AttributesImpl atts = new AttributesImpl(); |
| atts.addAttribute("http://some.other.uri", "gabba", "gabba:hey", |
| "int", "42"); |
| |
| try { |
| adapter.startElement("http://some.uri", "bar", "foo:bar", atts); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("startElement", logger.getMethod()); |
| assertEquals("foo:bar", logger.getArgs()[0]); |
| assertEquals("gabba:hey", |
| ((AttributeList)logger.getArgs()[1]).getName(0)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "endElement", |
| args = { String.class, String.class, String.class } |
| ) |
| public void testEndElement() { |
| try { |
| adapter.endElement("http://some.uri", "bar", "foo:bar"); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 1); |
| assertEquals("endElement", logger.getMethod()); |
| assertEquals(new Object[] { "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()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "skippedEntity", |
| args = { String.class } |
| ) |
| public void testSkippedEntity() { |
| try { |
| adapter.skippedEntity("foo"); |
| } catch (SAXException e) { |
| throw new RuntimeException("Unexpected exception", e); |
| } |
| |
| assertEquals(logger.size(), 0); |
| } |
| |
| } |