diff --git a/java/src/org/apache/qetest/xslwrapper/TraxStreamWrapper.java b/java/src/org/apache/qetest/xslwrapper/TraxStreamWrapper.java
new file mode 100644
index 0000000..4f9ccca
--- /dev/null
+++ b/java/src/org/apache/qetest/xslwrapper/TraxStreamWrapper.java
@@ -0,0 +1,530 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ *
+ * Copyright (c) 2001 The Apache Software Foundation.  All rights 
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ *    if any, must include the following acknowledgment:  
+ *       "This product includes software developed by the
+ *        Apache Software Foundation (http://www.apache.org/)."
+ *    Alternately, this acknowledgment may appear in the software itself,
+ *    if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Xalan" and "Apache Software Foundation" must
+ *    not be used to endorse or promote products derived from this
+ *    software without prior written permission. For written 
+ *    permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ *    nor may "Apache" appear in their name, without prior written
+ *    permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation and was
+ * originally based on software copyright (c) 1999, Lotus
+ * Development Corporation., http://www.lotus.com.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ */
+package org.apache.qetest.xslwrapper;
+import org.apache.qetest.QetestUtils;
+
+import javax.xml.transform.Templates;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.Source;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+import java.util.Hashtable;
+import java.util.Properties;
+
+/**
+ * Implementation of TransformWrapper that uses the TrAX API and 
+ * uses in-memory streams for it's sources.
+ *
+ * <p>This implementation separates the process of reading xml and xsl 
+ * files from disk into byte arrays out from the time processing of 
+ * a new StreamSource(byte[]) takes to build a stylesheet.
+ * It also separates the time of performing the transformation 
+ * to a StreamResult(byte[]) from the time spent simply sending 
+ * the byte[] through a FileOutputStream to disk.</p>
+ * 
+ * <p><b>Important!</b>  The underlying System property of 
+ * javax.xml.transform.TransformerFactory will determine the actual 
+ * TrAX implementation used.  This value will be reported out in 
+ * our getProcessorInfo() method.</p>
+ *
+ * <p>//@todo: currently limited to reading in files whose length 
+ * will fit into an int value.  The actual file reading routine 
+ * should be updated in several of our methods.</p>
+ * 
+ * @author Shane Curcuru
+ * @version $Id$
+ */
+public class TraxStreamWrapper extends TransformWrapperHelper
+{
+
+    /**
+     * TransformerFactory to use; constructed in newProcessor().
+     */
+    protected TransformerFactory factory = null;
+
+
+    /**
+     * Templates to use for buildStylesheet().
+     */
+    protected Templates builtTemplates = null;
+
+
+    /**
+     * Cached copy of newProcessor() Hashtable.
+     */
+    protected Hashtable newProcessorOpts = null;
+
+
+    /**
+     * Get a general description of this wrapper itself.
+     *
+     * @return Uses TrAX to perform transforms from StreamSource(systemId)
+     */
+    public String getDescription()
+    {
+        return "Uses TrAX to perform transforms from StreamSource(stream)";
+    }
+
+
+    /**
+     * Get a specific description of the wrappered processor.  
+     *
+     * @return specific description of the underlying processor or 
+     * transformer implementation: this should include both the 
+     * general product name, as well as specific version info.  If 
+     * possible, should be implemented without actively creating 
+     * an underlying processor.
+     */
+    public Properties getProcessorInfo()
+    {
+        Properties p = TraxWrapperUtils.getTraxInfo();
+        p.put("traxwrapper.method", "streams");
+        p.put("traxwrapper.desc", getDescription());
+        return p;
+    }
+
+
+    /**
+     * Actually create/initialize an underlying processor or factory.
+     * 
+     * For TrAX/javax.xml.transform implementations, this creates 
+     * a new TransformerFactory.  
+     *
+     * @param options Hashtable of options, unused.
+     *
+     * @return (Object)getProcessor() as a side-effect, this will 
+     * be null if there was any problem creating the processor OR 
+     * if the underlying implementation doesn't use this
+     *
+     * @throws Exception covers any underlying exceptions thrown 
+     * by the actual implementation
+     */
+    public Object newProcessor(Hashtable options) throws Exception
+    {
+        newProcessorOpts = options;
+        //@todo do we need to do any other cleanup?
+        reset(false);
+        factory = TransformerFactory.newInstance();
+        return (Object)factory;
+    }
+
+
+    /**
+     * Transform supplied xmlName file with the stylesheet in the 
+     * xslName file into a resultName file.
+     *
+     * Names are assumed to be local path\filename references, and 
+     * will be read as byte streams before being passed to 
+     * underlying StreamSources, etc.  
+     *
+     * @param xmlName local path\filename of XML file to transform
+     * @param xslName local path\filename of XSL stylesheet to use
+     * @param resultName local path\filename to put result in
+     *
+     * @return array of longs denoting timing of all parts of 
+     * our operation: IDX_OVERALL, IDX_XSLREAD, IDX_XSLBUILD, 
+     * IDX_XMLREAD, IDX_TRANSFORM, IDX_RESULTWRITE
+     *
+     * @throws Exception any underlying exceptions from the 
+     * wrappered processor are simply allowed to propagate; throws 
+     * a RuntimeException if any other problems prevent us from 
+     * actually completing the operation
+     */
+    public long[] transform(String xmlName, String xslName, String resultName)
+        throws Exception
+    {
+        preventFootShooting();
+        long startTime = 0;
+        long xslRead = 0;
+        long xslBuild = 0;
+        long xmlRead = 0;
+        long transform = 0;
+        long resultWrite = 0;
+   
+        File xslFile = new File(xslName);
+        int xslLength = new Long(xslFile.length()).intValue(); //@todo warning: possible overflow
+        byte[] xslBytes = new byte[xslLength];
+        FileInputStream xslStream = new FileInputStream(xslFile);
+        // Timed: read xsl into a byte array
+        startTime = System.currentTimeMillis();
+        int xslRetVal = xslStream.read(xslBytes);
+        xslRead = System.currentTimeMillis() - startTime;
+
+        // Untimed: create StreamSource and setSystemId
+        StreamSource xslSource = new StreamSource(new ByteArrayInputStream(xslBytes));
+        // Note that systemIds must be a legal URI
+        xslSource.setSystemId(QetestUtils.filenameToURL(xslName));
+
+        // Timed: build Transformer from StreamSource
+        startTime = System.currentTimeMillis();
+        Transformer transformer = factory.newTransformer(xslSource);
+        xslBuild = System.currentTimeMillis() - startTime;
+
+        File xmlFile = new File(xmlName);
+        int xmlLength = new Long(xmlFile.length()).intValue(); //@todo warning: possible overflow
+        byte[] xmlBytes = new byte[xmlLength];
+        FileInputStream xmlStream = new FileInputStream(xmlFile);
+        // Timed: read xml into a byte array
+        startTime = System.currentTimeMillis();
+        int xmlRetVal = xmlStream.read(xmlBytes);
+        xmlRead = System.currentTimeMillis() - startTime;
+
+        // Untimed: create StreamSource and setSystemId
+        StreamSource xmlSource = new StreamSource(new ByteArrayInputStream(xmlBytes));
+        xmlSource.setSystemId(QetestUtils.filenameToURL(xmlName));
+
+        // Untimed: create StreamResult
+        ByteArrayOutputStream outBytes = new ByteArrayOutputStream();
+        StreamResult byteResult = new StreamResult(outBytes);
+        
+        // Untimed: Apply any parameters needed
+        applyParameters(transformer);
+
+        // Timed: build xml (so to speak) and transform
+        startTime = System.currentTimeMillis();
+        transformer.transform(xmlSource, byteResult);
+        transform = System.currentTimeMillis() - startTime;
+
+        // Timed: writeResults from the byte array
+        startTime = System.currentTimeMillis();
+        byte[] writeBytes = outBytes.toByteArray(); // Should this be timed too or not?
+        FileOutputStream writeStream = new FileOutputStream(resultName);
+        writeStream.write(writeBytes);
+        writeStream.close();
+        resultWrite = System.currentTimeMillis() - startTime;
+
+        long[] times = getTimeArray();
+        times[IDX_OVERALL] = xslRead + xslBuild + xmlRead 
+                             + transform + resultWrite;
+        times[IDX_XSLREAD] = xslRead;
+        times[IDX_XSLBUILD] = xslBuild;
+        times[IDX_XMLREAD] = xmlRead;
+        times[IDX_TRANSFORM] = transform;
+        times[IDX_RESULTWRITE] = resultWrite;
+        return times;
+    }
+
+
+    /**
+     * Pre-build/pre-compile a stylesheet.
+     *
+     * Although the actual mechanics are implementation-dependent, 
+     * most processors have some method of pre-setting up the data 
+     * needed by the stylesheet itself for later use in transforms.
+     * In TrAX/javax.xml.transform, this equates to creating a 
+     * Templates object.
+     * 
+     * Sets isStylesheetReady() to true if it succeeds.  Users can 
+     * then call transformWithStylesheet(xmlName, resultName) to 
+     * actually perform a transformation with this pre-built 
+     * stylesheet.
+     *
+     * @param xslName local path\filename of XSL stylesheet to use
+     *
+     * @return array of longs denoting timing of all parts of 
+     * our operation: IDX_OVERALL, IDX_XSLREAD, IDX_XSLBUILD
+     *
+     * @throws Exception any underlying exceptions from the 
+     * wrappered processor are simply allowed to propagate; throws 
+     * a RuntimeException if any other problems prevent us from 
+     * actually completing the operation
+     *
+     * @see #transformWithStylesheet(String xmlName, String resultName)
+     */
+    public long[] buildStylesheet(String xslName) throws Exception
+    {
+        preventFootShooting();
+        long startTime = 0;
+        long xslRead = 0;
+        long xslBuild = 0;
+        
+        File xslFile = new File(xslName);
+        int xslLength = new Long(xslFile.length()).intValue(); //@todo warning: possible overflow
+        byte[] xslBytes = new byte[xslLength];
+        FileInputStream xslStream = new FileInputStream(xslFile);
+        // Timed: read xsl into a byte array
+        startTime = System.currentTimeMillis();
+        int xslRetVal = xslStream.read(xslBytes);
+        xslRead = System.currentTimeMillis() - startTime;
+
+        // Untimed: create StreamSource and setSystemId
+        StreamSource xslSource = new StreamSource(new ByteArrayInputStream(xslBytes));
+        // Note that systemIds must be a legal URI
+        xslSource.setSystemId(QetestUtils.filenameToURL(xslName));
+
+        // Timed: build Transformer from StreamSource
+        startTime = System.currentTimeMillis();
+        builtTemplates = factory.newTemplates(xslSource);
+        xslBuild = System.currentTimeMillis() - startTime;
+
+        // Set internal state that we have a templates ready
+        //  Note: in theory, there's no need to check builtTemplates
+        //  since the newTemplates should never return null
+        //  (it might have thrown an exception, but we don't care)
+        m_stylesheetReady = true;
+
+        long[] times = getTimeArray();
+        times[IDX_OVERALL] = xslBuild + xslRead;
+        times[IDX_XSLREAD] = xslRead;
+        times[IDX_XSLBUILD] = xslBuild;
+        return times;
+    }
+
+
+    /**
+     * Transform supplied xmlName file with a pre-built/pre-compiled 
+     * stylesheet into a resultName file.  
+     *
+     * User must have called buildStylesheet(xslName) beforehand,
+     * obviously.
+     * Names are assumed to be local path\filename references, and 
+     * will be converted to URLs as needed.
+     *
+     * @param xmlName local path\filename of XML file to transform
+     * @param resultName local path\filename to put result in
+     *
+     * @return array of longs denoting timing of all parts of 
+     * our operation: IDX_OVERALL, 
+     * IDX_XMLREAD, IDX_TRANSFORM, IDX_RESULTWRITE
+     *
+     * @throws Exception any underlying exceptions from the 
+     * wrappered processor are simply allowed to propagate; throws 
+     * a RuntimeException if any other problems prevent us from 
+     * actually completing the operation; throws an 
+     * IllegalStateException if isStylesheetReady() == false.
+     *
+     * @see #buildStylesheet(String xslName)
+     */
+    public long[] transformWithStylesheet(String xmlName, String resultName)
+        throws Exception
+    {
+        if (!isStylesheetReady())
+            throw new IllegalStateException("transformWithStylesheet() when isStylesheetReady() == false");
+
+        preventFootShooting();
+        long startTime = 0;
+        long xslRead = 0;
+        long xslBuild = 0;
+        long xmlRead = 0;
+        long transform = 0;
+        long resultWrite = 0;
+   
+        // UNTimed: get Transformer from Templates
+        Transformer transformer = builtTemplates.newTransformer();
+
+        File xmlFile = new File(xmlName);
+        int xmlLength = new Long(xmlFile.length()).intValue(); //@todo warning: possible overflow
+        byte[] xmlBytes = new byte[xmlLength];
+        FileInputStream xmlStream = new FileInputStream(xmlFile);
+        // Timed: read xml into a byte array
+        startTime = System.currentTimeMillis();
+        int xmlRetVal = xmlStream.read(xmlBytes);
+        xmlRead = System.currentTimeMillis() - startTime;
+
+        // Untimed: create StreamSource and setSystemId
+        StreamSource xmlSource = new StreamSource(new ByteArrayInputStream(xmlBytes));
+        xmlSource.setSystemId(QetestUtils.filenameToURL(xmlName));
+
+        // Untimed: create StreamResult
+        ByteArrayOutputStream outBytes = new ByteArrayOutputStream();
+        StreamResult byteResult = new StreamResult(outBytes);
+        
+        // Untimed: Apply any parameters needed
+        applyParameters(transformer);
+
+        // Timed: build xml (so to speak) and transform
+        startTime = System.currentTimeMillis();
+        transformer.transform(xmlSource, byteResult);
+        transform = System.currentTimeMillis() - startTime;
+
+        // Timed: writeResults from the byte array
+        startTime = System.currentTimeMillis();
+        byte[] writeBytes = outBytes.toByteArray(); // Should this be timed too or not?
+        FileOutputStream writeStream = new FileOutputStream(resultName);
+        writeStream.write(writeBytes);
+        writeStream.close();
+        resultWrite = System.currentTimeMillis() - startTime;
+
+        long[] times = getTimeArray();
+        times[IDX_OVERALL] = xmlRead + transform + resultWrite;
+        times[IDX_XMLREAD] = xmlRead;
+        times[IDX_TRANSFORM] = transform;
+        times[IDX_RESULTWRITE] = resultWrite;
+        return times;
+    }
+
+
+    /**
+     * Transform supplied xmlName file with a stylesheet found in an 
+     * xml-stylesheet PI into a resultName file.
+     *
+     * Names are assumed to be local path\filename references, and 
+     * will be converted to URLs as needed.  Implementations will 
+     * use whatever facilities exist in their wrappered processor 
+     * to fetch and build the stylesheet to use for the transform.
+     *
+     * @param xmlName local path\filename of XML file to transform
+     * @param resultName local path\filename to put result in
+     *
+     * @return array of longs denoting timing of only these parts of 
+     * our operation: IDX_OVERALL, IDX_XSLREAD (time to find XSL
+     * reference from the xml-stylesheet PI), IDX_XSLBUILD, (time 
+     * to then build the Transformer therefrom), IDX_TRANSFORM
+     *
+     * @throws Exception any underlying exceptions from the 
+     * wrappered processor are simply allowed to propagate; throws 
+     * a RuntimeException if any other problems prevent us from 
+     * actually completing the operation
+     */
+    public long[] transformEmbedded(String xmlName, String resultName)
+        throws Exception
+    {
+        preventFootShooting();
+        long startTime = 0;
+        long xslRead = 0;
+        long xslBuild = 0;
+        long transform = 0;
+
+        throw new RuntimeException("transformEmbedded not implemented yet!");
+    }
+
+
+    /**
+     * Reset our parameters and wrapper state, and optionally 
+     * force creation of a new underlying processor implementation.
+     *
+     * This always clears our built stylesheet and any parameters 
+     * that have been set.  If newProcessor is true, also forces a 
+     * re-creation of our underlying processor as if by calling 
+     * newProcessor().
+     *
+     * @param newProcessor if we should reset our underlying 
+     * processor implementation as well
+     */
+    public void reset(boolean newProcessor)
+    {
+        super.reset(newProcessor); // clears indent and parameters
+        m_stylesheetReady = false;
+        builtTemplates = null;
+        if (newProcessor)
+        {
+            try
+            {
+                newProcessor(newProcessorOpts);
+            }
+            catch (Exception e)
+            {
+                //@todo Hmm: what should we do here?
+            }
+        }
+    }
+
+
+    /**
+     * Apply a single parameter to a Transformer.
+     *
+     * Overridden to take a Transformer and call setParameter().
+     *
+     * @param passThru to be passed to each applyParameter() method 
+     * call - for TrAX, you might pass a Transformer object.
+     * @param namespace for the parameter, may be null
+     * @param name for the parameter, should not be null
+     * @param value for the parameter, may be null
+     */
+    protected void applyParameter(Object passThru, String namespace, 
+                                  String name, Object value)
+    {
+        try
+        {
+            Transformer t = (Transformer)passThru;
+            // Munge the namespace into the name per 
+            //  javax.xml.transform.Transformer.setParameter()
+            if (null != namespace)
+            {
+                name = "{" + namespace + "}" + name;
+            }
+            t.setParameter(name, value);
+        }
+        catch (Exception e)
+        {
+            throw new IllegalArgumentException("applyParameter threw: " + e.toString());
+        }
+    }
+
+
+    /**
+     * Ensure newProcessor has been called when needed.
+     *
+     * Prevent users from shooting themselves in the foot by 
+     * calling a transform* API before newProcessor().
+     *
+     * (Sorry, I couldn't resist)
+     */
+    public void preventFootShooting() throws Exception
+    {
+        if (null == factory)
+            newProcessor(newProcessorOpts);
+    }
+}