/*
 * Copyright 2004,2005 The Apache Software Foundation.
 * Copyright 2006 International Business Machines Corp.
 *
 * 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 org.apache.axis2.jaxws.message;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Map;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBIntrospector;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.util.JAXBSource;
import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMOutputFormat;
import org.apache.axiom.om.impl.builder.StAXOMBuilder;
import org.apache.axis2.jaxws.message.factory.BlockFactory;
import org.apache.axis2.jaxws.message.factory.JAXBBlockFactory;
import org.apache.axis2.jaxws.message.factory.MessageFactory;
import org.apache.axis2.jaxws.message.factory.OMBlockFactory;
import org.apache.axis2.jaxws.message.factory.SourceBlockFactory;
import org.apache.axis2.jaxws.message.factory.XMLStringBlockFactory;
import org.apache.axis2.jaxws.message.util.Reader2Writer;
import org.apache.axis2.jaxws.registry.FactoryRegistry;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;

import test.EchoString;
import test.ObjectFactory;

import junit.framework.TestCase;

/**
 * BlockTests
 * Tests to create and validate blocks.
 * These are not client/server tests.
 */
public class BlockTests extends TestCase {

	// String test variables
	private static final String sampleText =
		"<pre:a xmlns:pre=\"urn://sample\">" +
		"<b>Hello</b>" +
		"<c>World</c>" +
		"</pre:a>";
	private static final QName sampleQName = new QName("urn://sample", "a");
	
	
	private static XMLInputFactory inputFactory = XMLInputFactory.newInstance();
	private static XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
	
	
	
	public BlockTests() {
		super();
	}

	public BlockTests(String arg0) {
		super(arg0);
	}
	
	/**
	 * Create a Block representing an XMLString and simulate a 
	 * normal Dispatch<String> flow
	 * @throws Exception
	 */
	public void testStringOutflow() throws Exception {
		// Get the BlockFactory
		XMLStringBlockFactory f = (XMLStringBlockFactory)
			FactoryRegistry.getFactory(XMLStringBlockFactory.class);
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS dispatch<String> client
		Block block = f.createFrom(sampleText, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}

	/**
	 * Create a Block representing an XMLString and
	 * simulate a different Dispatch<String> flow
	 * @throws Exception
	 */
	public void testStringOutflow2() throws Exception {
		// Get the BlockFactory
		XMLStringBlockFactory f = (XMLStringBlockFactory)
			FactoryRegistry.getFactory(XMLStringBlockFactory.class);
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS dispatch<String> client
		Block block = f.createFrom(sampleText, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assume that we need to find the QName (perhaps to identify the operation and 
		// determine if handlers are installed).   This is not very perfomant since 
		// it causes an underlying parse of the String...but we need to support this.
		QName qName = block.getQName();
		assertTrue("Expected: " + sampleQName + " but found: " + qName, sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}
	
	/**
	 * Create a Block representing an XMLString and
	 * simulate a different String parameter flow
	 * @throws Exception
	 */
	public void testStringOutflow3() throws Exception {
		// Get the BlockFactory
		XMLStringBlockFactory f = (XMLStringBlockFactory)
			FactoryRegistry.getFactory(XMLStringBlockFactory.class);
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS String parameter on the client.
		// In this case, we know the QName prior to creating the Block...so let's pass it in.
		Block block = f.createFrom(sampleText, null, sampleQName);
		
		// We passed in a qname, so it should be immediately available
		assertTrue(block.isQNameAvailable());
		
		// Make sure the QName is correct.
		QName qName = block.getQName();
		assertTrue(sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
	}
	
	/**
	 * Create a Block representing an XMLString and simulate a 
	 * normal Dispatch<String> input flow
	 * @throws Exception
	 */
	public void testStringInflow() throws Exception {
		// Get the BlockFactory
		XMLStringBlockFactory f = (XMLStringBlockFactory)
			FactoryRegistry.getFactory(XMLStringBlockFactory.class);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object (String).
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof String);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check the String for accuracy
		assertTrue(sampleText.equals(bo.toString()));
		
	}
	
	/**
	 * Create a Block representing an XMLString and simulate a 
	 * slightly more complicated Dispatch<String> inflow
	 * @throws Exception
	 */
	public void testStringInflow2() throws Exception {
		// Get the BlockFactory
		XMLStringBlockFactory f = (XMLStringBlockFactory)
			FactoryRegistry.getFactory(XMLStringBlockFactory.class);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Let's assume we need to get the QName to find the operation name.
		// This will cause an underlying parse
		QName qName = block.getQName();
		assertTrue(sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object (String).
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof String);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check the String for accuracy
		assertTrue(sampleText.equals(bo.toString()));
		
	}
	
	/**
	 * Create a Block representing an XMLString and simulate a 
	 * slightly more complicated String  inflow
	 * @throws Exception
	 */
	public void testStringInflow3() throws Exception {
		// Get the BlockFactory
		XMLStringBlockFactory f = (XMLStringBlockFactory)
			FactoryRegistry.getFactory(XMLStringBlockFactory.class);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  Assume that we know the QName already
		Block block = f.createFrom(inflow, null, sampleQName);
		
		// We passed in a qname, so the following should return false
		assertTrue(block.isQNameAvailable());
		
		// Let's assume we need to get the QName to find the operation name.
		QName qName = block.getQName();
		assertTrue(sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object (String).
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof String);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check the String for accuracy
		assertTrue(sampleText.equals(bo.toString()));
		
	}
	
	/**
	 * Create a Block representing an JAXB and simulate a 
	 * normal Dispatch<JAXB> flow
	 * @throws Exception
	 */
	public void testJAXBOutflow() throws Exception {
		// Get the BlockFactory
		JAXBBlockFactory f = (JAXBBlockFactory)
			FactoryRegistry.getFactory(JAXBBlockFactory.class);
		
        // Create a jaxb object
        ObjectFactory factory = new ObjectFactory();
        EchoString jaxb = factory.createEchoString(); 
        jaxb.setInput("Hello World");
        JAXBContext jbc = JAXBContext.newInstance("test");
        JAXBIntrospector jbi = jbc.createJAXBIntrospector();
        QName expectedQName = jbi.getElementName(jaxb);
        
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS dispatch<JAXB> client
		Block block = f.createFrom(jaxb, jbc, null);
		
		// JAXB objects set the qname from their internal data
		assertTrue(block.isQNameAvailable());
		
		// Assume that we need to find the QName (perhaps to identify the operation and 
		// determine if handlers are installed).   This is not very perfomant since 
		// it causes an underlying parse of the String...but we need to support this.
		QName qName = block.getQName();
		assertTrue("Expected: " + expectedQName + " but found: " + qName, expectedQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(newText.contains("Hello World"));
		assertTrue(newText.contains("echoString"));
		
	}
	
	/**
	 * Create a Block representing an JAXB and simulate a 
	 * slightly more complicated Dispatch<JAXB> flow
	 * @throws Exception
	 */
	public void testJAXBOutflow2() throws Exception {
		// Get the BlockFactory
		JAXBBlockFactory f = (JAXBBlockFactory)
			FactoryRegistry.getFactory(JAXBBlockFactory.class);
		
        // Create a jaxb object
        ObjectFactory factory = new ObjectFactory();
        EchoString jaxb = factory.createEchoString(); 
        jaxb.setInput("Hello World");
        JAXBContext jbc = JAXBContext.newInstance("test");
        JAXBIntrospector jbi = jbc.createJAXBIntrospector();
        QName expectedQName = jbi.getElementName(jaxb);
        
		// Create a Block using the sample string as the content.  This simulates
		// what occurs with an outbound JAX-WS JAXB parameter
		Block block = f.createFrom(jaxb, jbc, expectedQName);
		
		// We did pass in a qname, so the following should return false
		assertTrue(block.isQNameAvailable());
		
		// Assume that we need to find the QName (perhaps to identify the operation and 
		// determine if handlers are installed).   This is not very perfomant since 
		// it causes an underlying parse of the String...but we need to support this.
		QName qName = block.getQName();
		assertTrue("Expected: " + expectedQName + " but found: " + qName, expectedQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(newText.contains("Hello World"));
		assertTrue(newText.contains("echoString"));
		
	}
	
	/**
	 * Create a Block representing an JAXB and simulate a 
	 * normal Dispatch<JAXB> input flow
	 * @throws Exception
	 */
	public void testJAXBInflow() throws Exception {
		// Get the BlockFactory
		JAXBBlockFactory f = (JAXBBlockFactory)
			FactoryRegistry.getFactory(JAXBBlockFactory.class);
		
        // Create a jaxb object
        ObjectFactory factory = new ObjectFactory();
        EchoString jaxb = factory.createEchoString(); 
        jaxb.setInput("Hello World");
        JAXBContext jbc = JAXBContext.newInstance("test");
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
        StringWriter sw = new StringWriter();
        XMLStreamWriter writer = outputFactory.createXMLStreamWriter(sw);
        jbc.createMarshaller().marshal(jaxb, writer);
        writer.flush();
        sw.flush();
		StringReader sr = new StringReader(sw.toString());
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, jbc, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object.
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof EchoString);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check for accuracy
		assertTrue("Unexpected:" + ((EchoString)bo).getInput(), ((EchoString)bo).getInput().equals(jaxb.getInput()));
		
	}
	
	/**
	 * Create a Block representing an JAXB and simulate a 
	 * normal Dispatch<JAXB> input flow
	 * @throws Exception
	 */
	public void testJAXBInflow2() throws Exception {
		// Get the BlockFactory
		JAXBBlockFactory f = (JAXBBlockFactory)
			FactoryRegistry.getFactory(JAXBBlockFactory.class);
		
        // Create a jaxb object
        ObjectFactory factory = new ObjectFactory();
        EchoString jaxb = factory.createEchoString(); 
        jaxb.setInput("Hello World");
        JAXBContext jbc = JAXBContext.newInstance("test");
        JAXBIntrospector jbi = jbc.createJAXBIntrospector();
        QName expectedQName = jbi.getElementName(jaxb);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
        StringWriter sw = new StringWriter();
        XMLStreamWriter writer = outputFactory.createXMLStreamWriter(sw);
        jbc.createMarshaller().marshal(jaxb, writer);
        writer.flush();
        sw.flush();
		StringReader sr = new StringReader(sw.toString());
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, jbc, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assume that we need to find the QName (perhaps to identify the operation and 
		// determine if handlers are installed).   This is not very perfomant since 
		// it causes an underlying parse of the String...but we need to support this.
		QName qName = block.getQName();
		assertTrue("Expected: " + expectedQName + " but found: " + qName, expectedQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object.
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof EchoString);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check for accuracy
		assertTrue("Unexpected:" + ((EchoString)bo).getInput(), ((EchoString)bo).getInput().equals(jaxb.getInput()));
		
	}
	
	/**
	 * Create a Block representing an JAXB and simulate a 
	 * normal Dispatch<JAXB> input flow
	 * @throws Exception
	 */
	public void testJAXBInflow3() throws Exception {
		// Get the BlockFactory
		JAXBBlockFactory f = (JAXBBlockFactory)
			FactoryRegistry.getFactory(JAXBBlockFactory.class);
		
        // Create a jaxb object
        ObjectFactory factory = new ObjectFactory();
        EchoString jaxb = factory.createEchoString(); 
        jaxb.setInput("Hello World");
        JAXBContext jbc = JAXBContext.newInstance("test");
        JAXBIntrospector jbi = jbc.createJAXBIntrospector();
        QName expectedQName = jbi.getElementName(jaxb);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
        StringWriter sw = new StringWriter();
        XMLStreamWriter writer = outputFactory.createXMLStreamWriter(sw);
        jbc.createMarshaller().marshal(jaxb, writer);
        writer.flush();
        sw.flush();
		StringReader sr = new StringReader(sw.toString());
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, jbc, expectedQName);
		
		// We passed in a qname, so the following should return false
		assertTrue(block.isQNameAvailable());
		
		// Assume that we need to find the QName (perhaps to identify the operation and 
		// determine if handlers are installed).   This is not very perfomant since 
		// it causes an underlying parse of the String...but we need to support this.
		QName qName = block.getQName();
		assertTrue("Expected: " + expectedQName + " but found: " + qName, expectedQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object.
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof EchoString);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check for accuracy
		assertTrue("Unexpected:" + ((EchoString)bo).getInput(), ((EchoString)bo).getInput().equals(jaxb.getInput()));
		
	}
	
	/**
	 * Create a Block representing an OM and simulate a 
	 * normal Dispatch<OMElement> flow
	 * @throws Exception
	 */
	public void testOMOutflow() throws Exception {
		// Get the BlockFactory
		OMBlockFactory f = (OMBlockFactory)
			FactoryRegistry.getFactory(OMBlockFactory.class);
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS dispatch<OMElement> client
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inputReader = inputFactory.createXMLStreamReader(sr);
		StAXOMBuilder builder = new StAXOMBuilder(inputReader);  
		OMElement om = builder.getDocumentElement();
		Block block = f.createFrom(om, null, null);
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}
	

	/**
	 * Create a Block representing an OM and simulate a 
	 * different Dispatch<OMElement> flow
	 * @throws Exception
	 */
	public void testOMOutflow2() throws Exception {
		// Get the BlockFactory
		OMBlockFactory f = (OMBlockFactory)
			FactoryRegistry.getFactory(OMBlockFactory.class);
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS dispatch<OMElement> client
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inputReader = inputFactory.createXMLStreamReader(sr);
		StAXOMBuilder builder = new StAXOMBuilder(inputReader);  
		OMElement om = builder.getDocumentElement();
		Block block = f.createFrom(om, null, null);
		
		// Assume that we need to find the QName (perhaps to identify the operation and 
		// determine if handlers are installed).   This is not very perfomant since 
		// it causes an underlying parse of the String...but we need to support this.
		QName qName = block.getQName();
		assertTrue("Expected: " + sampleQName + " but found: " + qName, sampleQName.equals(qName));
		
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}
	
	/**
	 * Create a Block representing an XMLString and simulate a 
	 *  Dispatch<OMElement> inflow
	 * @throws Exception
	 */
	public void testOMInflow() throws Exception {
		// Get the BlockFactory
		OMBlockFactory f = (OMBlockFactory)
			FactoryRegistry.getFactory(OMBlockFactory.class);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, null, null);
		
		// Let's assume we need to get the QName to find the operation name.
		// This will cause an underlying parse
		QName qName = block.getQName();
		assertTrue(sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object (String).
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof OMElement);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check the String for accuracy
		assertTrue(sampleText.equals(bo.toString()));
		
	}
	
	/**
	 * Create a Block representing a Source and simulate a 
	 * normal Dispatch<Source> flow
	 * @throws Exception
	 */
	public void testStreamSourceOutflow() throws Exception {
		// Get the BlockFactory
		SourceBlockFactory f = (SourceBlockFactory)
			FactoryRegistry.getFactory(SourceBlockFactory.class);
		
		StreamSource ss = new StreamSource(new StringReader(sampleText));
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS dispatch<Source> client
		Block block = f.createFrom(ss, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}

	/**
	 * Create a Block representing a Source and
	 * simulate a different Dispatch<Source> flow
	 * @throws Exception
	 */
	public void testStreamSourceOutflow2() throws Exception {
		// Get the BlockFactory
		SourceBlockFactory f = (SourceBlockFactory)
			FactoryRegistry.getFactory(SourceBlockFactory.class);
		
		StreamSource ss = new StreamSource(new StringReader(sampleText));
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS dispatch<Source> client
		Block block = f.createFrom(ss, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assume that we need to find the QName (perhaps to identify the operation and 
		// determine if handlers are installed).   This is not very perfomant since 
		// it causes an underlying parse of the String...but we need to support this.
		QName qName = block.getQName();
		assertTrue("Expected: " + sampleQName + " but found: " + qName, sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}
	
	/**
	 * Create a Block representing a Source and
	 * simulate a different Source parameter flow
	 * @throws Exception
	 */
	public void testStreamSourceOutflow3() throws Exception {
		// Get the BlockFactory
		SourceBlockFactory f = (SourceBlockFactory)
			FactoryRegistry.getFactory(SourceBlockFactory.class);
		
		StreamSource ss = new StreamSource(new StringReader(sampleText));
		
		// Create a Block using the sample string as the content.  This simulates
		// what occurs on the outbound JAX-WS String parameter on the client.
		// In this case, we know the QName prior to creating the Block...so let's pass it in.
		Block block = f.createFrom(ss, null, sampleQName);
		
		// We passed in a qname, so it should be immediately available
		assertTrue(block.isQNameAvailable());
		
		// Make sure the QName is correct.
		QName qName = block.getQName();
		assertTrue(sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is a XMLStreamReader will be requested...to go to OM.   At this point the
		// block should be consumed.
		XMLStreamReader reader = block.getXMLStreamReader(true);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// To check that the output is correct, get the String contents of the 
		// reader
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
	}
	
	/**
	 * Create a Block representing an XMLString and simulate a 
	 * normal Dispatch<Source> input flow
	 * @throws Exception
	 */
	public void testStreamSourceInflow() throws Exception {
		// Get the BlockFactory
		SourceBlockFactory f = (SourceBlockFactory)
			FactoryRegistry.getFactory(SourceBlockFactory.class);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object (String).
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof Source);
		
		// The block should be consumed
		assertTrue(block.isConsumed());
		
		// Check the String for accuracy
		XMLStreamReader reader = inputFactory.createXMLStreamReader((Source) bo);
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}
	
	/**
	 * Create a Block representing an XMLString and simulate a 
	 * slightly more complicated Dispatch<Source> inflow
	 * @throws Exception
	 */
	public void testStreamSourceInflow2() throws Exception {

		// Get the BlockFactory
		SourceBlockFactory f = (SourceBlockFactory)
			FactoryRegistry.getFactory(SourceBlockFactory.class);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  
		Block block = f.createFrom(inflow, null, null);
		
		// We didn't pass in a qname, so the following should return false
		assertTrue(!block.isQNameAvailable());
		
		// Let's assume we need to get the QName to find the operation name.
		// This will cause an underlying parse
		QName qName = block.getQName();
		assertTrue(sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object (String).
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof Source);
		
		// The block should be consumed
		assertTrue(block.isConsumed());

		// Check the String for accuracy
		XMLStreamReader reader = inputFactory.createXMLStreamReader((Source) bo);
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}
	
	/**
	 * Create a Block representing an Source and simulate a 
	 * slightly more complicated Source inflow
	 * @throws Exception
	 */
	public void testStreamSourceInflow3() throws Exception {

		// Get the BlockFactory
		SourceBlockFactory f = (SourceBlockFactory)
			FactoryRegistry.getFactory(SourceBlockFactory.class);
		
		// On inbound, there will already be a XMLStreamReader (probably from OM)
		// which represents the message.  We will simulate this with inflow.
		StringReader sr = new StringReader(sampleText);
		XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr);
		
		// Create a Block from the inflow.  Assume that we know the QName already
		Block block = f.createFrom(inflow, null, sampleQName);
		
		// We passed in a qname, so the following should return false
		assertTrue(block.isQNameAvailable());
		
		// Let's assume we need to get the QName to find the operation name.
		QName qName = block.getQName();
		assertTrue(sampleQName.equals(qName));
		
		// Assuming no handlers are installed, the next thing that will happen
		// is the proxy code will ask for the business object (String).
		Object bo = block.getBusinessObject(true);
		assertTrue(bo instanceof Source);
		
		// The block should be consumed
		assertTrue(block.isConsumed());

		// Check the String for accuracy
		XMLStreamReader reader = inputFactory.createXMLStreamReader((Source) bo);
		Reader2Writer r2w = new Reader2Writer(reader);
		String newText = r2w.getAsString();
		assertTrue(sampleText.equals(newText));
		
	}
    /*
     * Testing JAXBSource, Creating Source Block using JAXBSource and then
     * Serializing it.
     */
	public void testJAXBSourceInFlow1()throws Exception{
		//  Create a jaxb object
		try{
	        ObjectFactory factory = new ObjectFactory();
	        EchoString jaxb = factory.createEchoString(); 
	        jaxb.setInput("Hello World");
	        JAXBContext jbc = JAXBContext.newInstance("test");
	        JAXBSource src = new JAXBSource(jbc.createMarshaller(), jaxb);
	        BlockFactory f = (SourceBlockFactory)
				FactoryRegistry.getFactory(SourceBlockFactory.class);
	        
	        Block block =f.createFrom(src, null, null);
	        
	        MessageFactory mf = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class);
	        Message msg = mf.create(Protocol.soap11);
	        msg.setBodyBlock(0,block);
	        org.apache.axiom.soap.SOAPEnvelope env = (org.apache.axiom.soap.SOAPEnvelope)msg.getAsOMElement();
	        // Serialize the Envelope using the same mechanism as the 
	        // HTTP client.
	        ByteArrayOutputStream baos = new ByteArrayOutputStream();
	        env.serializeAndConsume(baos, new OMOutputFormat());
	        
	        // To check that the output is correct, get the String contents of the 
	        // reader
	        String newText = baos.toString();
	        System.out.println(newText);
	        assertTrue(block.isConsumed());
		}catch(Exception e){
			e.printStackTrace();
		}     
	}
	
	public void testJAXBSourceOutflow() throws Exception {
		
		//Sample text for JAXBSource
		String echoSample = "<echoString xmlns=\"http://test\"><input>Hello World</input></echoString>";
		
        // Get the BlockFactory
        SourceBlockFactory f = (SourceBlockFactory)
            FactoryRegistry.getFactory(SourceBlockFactory.class);
        //Create a JAXBSource
        
        JAXBContext jbc = JAXBContext.newInstance("test");
        Unmarshaller u = jbc.createUnmarshaller();
        ByteArrayInputStream inputStream = new ByteArrayInputStream(echoSample.getBytes());
        EchoString jaxb = (EchoString)u.unmarshal(inputStream);
        JAXBSource src = new JAXBSource(jbc.createMarshaller(), jaxb);
        
        // Create a Block using the sample string as the content.  This simulates
        // what occurs on the outbound JAX-WS dispatch<Source> client
        Block block = f.createFrom(src, null, null);
        
        // We didn't pass in a qname, so the following should return false
        assertTrue(!block.isQNameAvailable());
        
        // Assuming no handlers are installed, the next thing that will happen
        // is a XMLStreamReader will be requested...to go to OM.   At this point the
        // block should be consumed.
        XMLStreamReader reader = block.getXMLStreamReader(true);
        
        // The block should be consumed
        assertTrue(block.isConsumed());
        
        // To check that the output is correct, get the String contents of the 
        // reader
        Reader2Writer r2w = new Reader2Writer(reader);
        String newText = r2w.getAsString();
        assertTrue(echoSample.equals(newText));
    }
    /**
     * Create a Block representing a DOMSource instance and simulate an 
     * outbound flow
     * @throws Exception
     */
    public void testDOMSourceOutflow() throws Exception {
        // Get the BlockFactory
        SourceBlockFactory f = (SourceBlockFactory)
            FactoryRegistry.getFactory(SourceBlockFactory.class);
        
        // Turn the content into a stream
        ByteArrayInputStream bais = new ByteArrayInputStream(sampleText.getBytes());
        
        // Create a DOM tree from the sample text
        DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
        domFactory.setNamespaceAware(true);
        DocumentBuilder domBuilder = domFactory.newDocumentBuilder();
        Document domTree = domBuilder.parse(bais);
        Node node = domTree.getDocumentElement();
        System.out.println(node.toString());
        
        // Create a DOMSource object from the DOM tree
        DOMSource ds = new DOMSource(node);
        node = ds.getNode();
        
        // Create a Block using the sample string as the content.  This simulates
        // what occurs on the outbound JAX-WS dispatch<Source> client
        Block block = f.createFrom(ds, null, null);
        
        // We didn't pass in a qname, so the following should return false
        assertTrue(!block.isQNameAvailable());
        
        // Assuming no handlers are installed, the next thing that will happen
        // is a XMLStreamReader will be requested...to go to OM.   At this point the
        // block should be consumed.
        XMLStreamReader reader = block.getXMLStreamReader(true);
        
        // The block should be consumed
        assertTrue(block.isConsumed());
        
        // To check that the output is correct, get the String contents of the 
        // reader
        Reader2Writer r2w = new Reader2Writer(reader);
        String newText = r2w.getAsString();
        assertTrue(sampleText.equals(newText));
    }
    
    /**
     * Create a Block representing a SAXSource instance and simulate an 
     * outbound flow
     * @throws Exception
     */
    public void testSAXSourceOutflow() throws Exception {
        // Get the BlockFactory
        SourceBlockFactory f = (SourceBlockFactory)
            FactoryRegistry.getFactory(SourceBlockFactory.class);
        
        // Create a SAXSource from the sample text
        byte[] bytes = sampleText.getBytes();
        ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
        InputSource input = new InputSource(stream);
        SAXSource ss = new SAXSource(input);
        
        // Create a Block using the sample string as the content.  This simulates
        // what occurs on the outbound JAX-WS dispatch<Source> client
        Block block = f.createFrom(ss, null, null);
        
        // We didn't pass in a qname, so the following should return false
        assertTrue(!block.isQNameAvailable());
        
        // Assuming no handlers are installed, the next thing that will happen
        // is a XMLStreamReader will be requested...to go to OM.   At this point the
        // block should be consumed.
        XMLStreamReader reader = block.getXMLStreamReader(true);
        
        // The block should be consumed
        assertTrue(block.isConsumed());
        
        // To check that the output is correct, get the String contents of the 
        // reader
        Reader2Writer r2w = new Reader2Writer(reader);
        String newText = r2w.getAsString();
        assertTrue(sampleText.equals(newText));
    }

}