src/test/java/org/apache/vysper/xml/sax/impl/AbstractAsyncXMLReaderTestCase.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you 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 org.apache.vysper.xml.sax.impl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import junit.framework.TestCase;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.vysper.charset.CharsetUtil;
import org.apache.vysper.xml.sax.NonBlockingXMLReader;
import org.apache.vysper.xml.sax.impl.TestHandler.CharacterEvent;
import org.apache.vysper.xml.sax.impl.TestHandler.EndDocumentEvent;
import org.apache.vysper.xml.sax.impl.TestHandler.EndElementEvent;
import org.apache.vysper.xml.sax.impl.TestHandler.FatalErrorEvent;
import org.apache.vysper.xml.sax.impl.TestHandler.StartDocumentEvent;
import org.apache.vysper.xml.sax.impl.TestHandler.StartElementEvent;
import org.apache.vysper.xml.sax.impl.TestHandler.TestEvent;
import org.xml.sax.Attributes;


/**
 * @author The Apache MINA Project (dev@mina.apache.org)
 */
public abstract class AbstractAsyncXMLReaderTestCase extends TestCase {

	private static final Attributes EMPTY_ATTRIBUTES = new DefaultAttributes();
	
	protected void assertStartElement(String expectedUri, String expectedLocalName, String expectedQName, 
			TestEvent actual) {
		assertStartElement(expectedUri, expectedLocalName, expectedQName, EMPTY_ATTRIBUTES, actual);
	}

	protected Attributes attributes(Attribute...attributes) {
		List<Attribute> list = new ArrayList<Attribute>();
		for(Attribute attribute : attributes) {
			list.add(attribute);
		}
		return new DefaultAttributes(list);
	}
	
	protected void assertStartElement(String expectedUri, String expectedLocalName, String expectedQName, Attributes expectedAttributes, 
			TestEvent actual) {
		if(!(actual instanceof StartElementEvent)) fail("Event must be StartElementEvent but was " + actual.getClass());
		StartElementEvent startElementEvent = (StartElementEvent) actual;
		assertEquals("URI", expectedUri, startElementEvent.getURI());
		assertEquals("local name", expectedLocalName, startElementEvent.getLocalName());
		assertEquals("qName", expectedQName, startElementEvent.getQName());
		assertAttributes(expectedAttributes, startElementEvent.getAtts());
	}

	protected void assertAttributes(Attributes expectedAttrs, Attributes actualAttrs) {
		assertEquals("Attribute count", expectedAttrs.getLength(), actualAttrs.getLength());
		
		for(int i = 0; i<expectedAttrs.getLength(); i++) {
			assertEquals("Local name[" + i + "]", expectedAttrs.getLocalName(i), actualAttrs.getLocalName(i));
			assertEquals("Qname[" + i + "]", expectedAttrs.getQName(i), actualAttrs.getQName(i));
			assertEquals("URI[" + i + "]", expectedAttrs.getURI(i), actualAttrs.getURI(i));
			assertEquals("Value[" + i + "]", expectedAttrs.getValue(i), actualAttrs.getValue(i));
		}
	}
	
	protected void assertEndElement(String expectedUri, String expectedLocalName, String expectedQName, 
			TestEvent actual) {
		if(!(actual instanceof EndElementEvent)) fail("Event must be EndElementEvent");
		EndElementEvent endElementEvent = (EndElementEvent) actual;
		assertEquals("URI", expectedUri, endElementEvent.getURI());
		assertEquals("local name", expectedLocalName, endElementEvent.getLocalName());
		assertEquals("qName", expectedQName, endElementEvent.getQName());
	}

	protected void assertStartDocument(TestEvent actual) {
		if(!(actual instanceof StartDocumentEvent)) fail("Event must be StartDocumentEvent but is " + actual.getClass());
	}

	protected void assertEndDocument(TestEvent actual) {
		if(!(actual instanceof EndDocumentEvent)) fail("Event must be EndDocumentEvent");
	}

	protected void assertText(String expected, TestEvent actual) {
		if(!(actual instanceof CharacterEvent)) fail("Event must be CharacterEvent");
		
		assertEquals(expected, ((CharacterEvent)actual).getCharacters());
	}

	protected List<TestEvent> parse(String xml) throws Exception {
		return parse(xml, null);
	}
	
	protected List<TestEvent> parse(String xml, Map<String, Boolean> features) throws Exception {
		TestHandler handler = new TestHandler();
		NonBlockingXMLReader reader = new DefaultNonBlockingXMLReader();
		if(features != null) {
			for(Entry<String, Boolean> feature : features.entrySet()) {
				reader.setFeature(feature.getKey(), feature.getValue());
			}
		}
		
		reader.setContentHandler(handler);
		reader.setErrorHandler(handler);

		reader.parse(IoBuffer.wrap(xml.getBytes("UTF-8")), CharsetUtil.UTF8_DECODER);
		
		return handler.getEvents();
	}

	protected void assertFatalError(TestEvent actual) {
		if(!(actual instanceof FatalErrorEvent)) fail("Event must be FatalErrorEvent but is "+ actual.getClass());
	}

	protected void assertNoMoreevents(Iterator events) {
		if(events.hasNext()) {
			fail("Must not be any more evens, but found one " + events.next().getClass());
		}
	}
}