qetest/xsl/ThreadedStylesheetTestlet.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.
 */
/*
 * $Id$
 */

/*
 *
 * ThreadedStylesheetTestlet.java
 *
 */
package org.apache.qetest.xsl;

import java.io.File;

import org.apache.qetest.CheckService;
import org.apache.qetest.Datalet;
import org.apache.qetest.Logger;
import org.apache.qetest.TestletImpl;
import org.apache.qetest.xslwrapper.TransformWrapper;
import org.apache.qetest.xslwrapper.TransformWrapperFactory;

/**
 * Testlet for basic thread testing of xsl stylesheet files.
 *
 * This class provides a simple testing algorithim for verifying
 * that Xalan functions properly when run on multiple threads
 * simultaneously.  Currently it simply does most of what the
 * normal StylesheetTestlet does, except it does it in the run()
 * method on a thread - thus you'd commonly use this with
 * ThreadedTestletDriver to start multiple of these testlets
 * up at the same time.
 * We implement Runnable, so classically a test driver would
 * create us then pass us to new Thread(us).start(), instead
 * of calling execute(). @todo find a better way to integrate!
 *
 * @author Shane_Curcuru@lotus.com
 * @version $Id$
 */
public class ThreadedStylesheetTestlet
        extends TestletImpl
        implements Runnable
{
    // Initialize our classname for TestletImpl's main() method
    static { thisClassName = "org.apache.qetest.xsl.ThreadedStylesheetTestlet"; }

    // Initialize our defaultDatalet
    { defaultDatalet = (Datalet)new StylesheetDatalet(); }

    /** Accessor for our Datalet instead of calling execute().  */
    public void setDefaultDatalet(StylesheetDatalet d)
    {
        defaultDatalet = d;
    }

    /* Special ThreadedStylesheetDatalet with a Templates.  */
    public ThreadedStylesheetDatalet sharedDatalet = new ThreadedStylesheetDatalet();

    /* Description of our current state; changes during our lifecycle.  */
    protected String description = "ThreadedStylesheetTestlet - before execute()";

    /**
     * Accesor method for a brief description of this test.
     * When created, this returns a description of this testlet.
     * After you've called execute(), this returns a brief
     * description of our current result or status.
     *
     * @return String describing what this ThreadedStylesheetTestlet does.
     * @see #getResult()
     */
    public String getDescription()
    {
        return description;
    }

    /**
     * Accesor method for a brief description of this test.
     * Automatically adds our identifier at the start.
     *
     * @param d String to set as our current description.
     */
    protected void setDescription(String d)
    {
        description = "[" + threadIdentifier + "]" + d;
    }

    /* Our 'final' test result; actually changes during our lifecycle.  */
    protected int result = Logger.DEFAULT_RESULT;

    /**
     * Accesor method for the final result of this test.
     * Note: this starts as INCP_RESULT, and given that we're
     * threaded, may end up as INCP_RESULT and you may not know
     * the difference.  Could use more thought.
     *
     * @return int one of of Logger.*_RESULT.
     */
    public int getResult()
    {
        return result;
    }

    /* Cheap-o counter: so driver can differentiate each thread.  */
    public int threadIdentifier = 0;

    /**
     * Run this ThreadedStylesheetTestlet: start this test as
     * a thread and return immediately.
     * Note that you must join() this thread later if you want
     * to wait until we're done.
     * //@todo improve docs on how to communicate between threads
     *
     * @param Datalet to use as data point for the test.
     */
    public void execute(Datalet d)
	{
        StylesheetDatalet datalet = null;
        try
        {
            datalet = (StylesheetDatalet)d;
        }
        catch (ClassCastException e)
        {
            logger.checkErr("Datalet provided is not a StylesheetDatalet; cannot continue with " + d);
            return;
        }

        logger.logMsg(Logger.STATUSMSG, "About to test: "
                      + (null == datalet.inputName
                         ? datalet.xmlName
                         : datalet.inputName)
                      + " plus " + sharedDatalet.xmlName);

        // All the rest of the test is executed in our thread.
        //if (true) //@todo check defaultDatalet.options...
        //    this.start();
        //@todo Um, how do we do this? Or do we just ask caller to do it?
        logger.logMsg(Logger.CRITICALMSG, "//@todo execute() is not yet implemented - you must start our thread yourself");

        // Return to caller; they must join() us later if they
        //  want to know when we're actually complete
        return;
    }

    /**
     * Called by execute() to perform the looping and actual test.
     * Note: You must have set our defaultDatalet first!
     */
    public void run()
    {
        // Relies on defaultDatalet being set!
        logger.logMsg(Logger.STATUSMSG, "Beginning thread shared output into: "
                      + ((StylesheetDatalet)defaultDatalet).outputName);
        // Also set our description so outside users know what
        // point in our Thread lifetime we're at
        setDescription("ThreadedStylesheetTestlet.run() just started...");

        StylesheetDatalet datalet = null;
        try
        {
            datalet = (StylesheetDatalet)defaultDatalet;
        }
        catch (ClassCastException e)
        {
            setDescription("Datalet provided is not a StylesheetDatalet; cannot continue with " + datalet);
            logger.checkErr(description);
            return;
        }
        //@todo validate our Datalet - ensure it has valid
        //  and/or existing files available.

        // Cleanup outName(s) only if asked to - delete the file on disk
        // Optimization: this takes extra time and often is not
        //  needed, so only do this if the option is set
        if ("true".equalsIgnoreCase(datalet.options.getProperty("deleteOutFile")))
        {
            try
            {
                boolean btmp = (new File(datalet.outputName)).delete();
                logger.logMsg(Logger.TRACEMSG, "Deleting OutFile of::" + datalet.outputName
                                     + " status: " + btmp);
            }
            catch (SecurityException se)
            {
                logger.logMsg(Logger.WARNINGMSG, "Deleting OutFile of::" + datalet.outputName
                                       + " threw: " + se.toString());
                // But continue anyways...
            }
            //@todo make sure all sharedDatalets use different
            //  output files! No sense in having them use
            //  the same file all the time in all threads!
        }

        // Ask our independent datalet how many iterations to use
        int iterations = sharedDatalet.iterations; // default value
        try
        {
            iterations = Integer.parseInt(datalet.options.getProperty("iterations"));
        }
        catch (NumberFormatException numEx)
        {
            // no-op; leave as default
        }

        // Now loop a number of times as specified, and for each
        //  loop, use the presupplied Templates object, then run
        //  one independent process, plus validate on first & last
        setDescription("...about to iterate... " + datalet.outputName);
        for (int ctr = 1; (ctr <= iterations); ctr++)
        {
            // Only validate on first and last iteration
            boolean doValidation = ((1 == ctr) || (iterations == ctr));
            logger.logMsg(Logger.TRACEMSG, "About to do iteration " + ctr);
            // Note: logic moved to worker methods for clarity;
            //  these methods just use our local vars and datalet
            //@todo Note: while I've tried to mirror as much
            //  structure from StylesheetTestlet as possible,
            //  this has made this class very inefficent (note
            //  we iterate, and within each method do the same
            //  name munging and some basic setup in each worker
            //  method every time!)
            // Long-term, we should just redesign this to be
            //  a custom class with it's own algorithim
            processExistingTemplates(sharedDatalet, doValidation);
            processNewStylesheet(datalet, doValidation);
            setDescription("...done iteration # " + ctr);
        }
        // That's it! We're done!
        logger.logMsg(Logger.STATUSMSG, "Completed thread with: " + datalet.getDescription());
        setDescription("All iterations complete! " + datalet.outputName);
        // Also set our result, now that we think we're done
        try
        {
            result = ((org.apache.qetest.Reporter)logger).getCurrentCaseResult();
        }
        catch (ClassCastException cce)
        {
            // Basically a no-op; just log out for info
            logger.logMsg(Logger.WARNINGMSG, "logger is not a Reporter; overall result may be incorrect!");
        }
	}


    /**
     * Worker method to process premade Templates object.
     * Uses various local variables.
     * //@todo Should we simply propagate exceptions instead of just logging them?
     */
    private void processExistingTemplates(ThreadedStylesheetDatalet datalet, boolean doValidation)
    {
        // First: use our (presumably) shared Templates object to
        // perform a Transformation - using the existing
        // TransformWrapper object that already has built a stylesheet
        if (!datalet.transformWrapper.isStylesheetReady())
        {
            // Can't continue if the Templates is not ready
            logger.logMsg(Logger.WARNINGMSG, "datalet shared Templates isStylesheetReady false!");
            // Anything else we should log out here?  In case someone
            //  care about this, don't have it fail
            return;
        }

        // Since the wrapper's ready (and flavor, etc. setup) then
        //  just go ahead and ask it to transform
        try
        {
            String outputName = datalet.outputName + threadIdentifier;

            //@todo Should we log a custom logElement here instead?
            logger.logMsg(Logger.TRACEMSG, "About to test shared Templates: "
                          + " xmlName=" + datalet.xmlName
                          + " outputName=" + outputName
                          + " goldName=" + datalet.goldName);

            // Simply have the wrapper do all the transforming
            //  or processing for us - we handle either normal .xsl
            //  stylesheet tests or just .xml embedded tests
            long retVal = 0L;
            // Here, we only use the existing Templates to do the transform
            long[] times = datalet.transformWrapper.transformWithStylesheet(datalet.xmlName, outputName);
            retVal = times[TransformWrapper.IDX_OVERALL];

            if (!doValidation)
            {
                logger.logMsg(Logger.TRACEMSG, "Skipping validation of outputName=" + outputName);
                // Only bother to validate the output if asked
                return;
            }
            // If we get here, attempt to validate the contents of
            //  the last outputFile created - only first and last time through loop!
            CheckService fileChecker = (CheckService)datalet.options.get("fileCheckerImpl");
            // Supply default value
            if (null == fileChecker)
                fileChecker = new XHTFileCheckService();
            fileChecker.check(logger,
                              new File(outputName),
                              new File(datalet.goldName),
                              "Shared Templates of: " + datalet.getDescription());
        }
        // Note that this class can only validate positive test
        //  cases - we don't handle ExpectedExceptions
        catch (Throwable t)
        {
            // Put the logThrowable first, so it appears before
            //  the Fail record, and gets color-coded
            logger.logThrowable(Logger.ERRORMSG, t, "Shared Templates of: " + datalet.getDescription());
            logger.checkFail("Shared Templates of: " + datalet.getDescription()
                             + " threw: " + t.toString());
        }
    }
    /**
     * Worker method to process a new stylesheet/xml document.
     * Uses various local variables.
     * Note this is essentially a copy of StylesheetTestlet.execute().
     * //@todo Should we simply propagate exceptions instead of just logging them?
     */
    private void processNewStylesheet(StylesheetDatalet datalet, boolean doValidation)
    {
        // Test our supplied input file, and compare with gold
        try
        {
            String outputName =  datalet.outputName + threadIdentifier;

            //@todo Should we log a custom logElement here instead?
            logger.logMsg(Logger.TRACEMSG, "About to test: inputName=" + datalet.inputName
                          + " xmlName=" + datalet.xmlName + " outputName=" + outputName
                          + " goldName=" + datalet.goldName + " flavor="  + datalet.flavor);

            // Create a new TransformWrapper of appropriate flavor
            //  null arg is unused liaison for TransformWrapper
            TransformWrapper transformWrapper = null;
            try
            {
                transformWrapper = TransformWrapperFactory.newWrapper(datalet.flavor);
                transformWrapper.newProcessor(null);
            }
            catch (Throwable t)
            {
                logger.logThrowable(Logger.ERRORMSG, t, getDescription() + " newWrapper/newProcessor threw");
                logger.checkErr(getDescription() + " newWrapper/newProcessor threw: " + t.toString());
                return;
            }

            // Simply have the wrapper do all the transforming
            //  or processing for us - we handle either normal .xsl
            //  stylesheet tests or just .xml embedded tests
            long retVal = 0L;
            if (null == datalet.inputName)
            {
                // presume it's an embedded test
                long [] times = transformWrapper.transformEmbedded(datalet.xmlName, outputName);
                retVal = times[TransformWrapper.IDX_OVERALL];
            }
            else
            {
                // presume it's a normal stylesheet test
                long[] times = transformWrapper.transform(datalet.xmlName, datalet.inputName, outputName);
                retVal = times[TransformWrapper.IDX_OVERALL];
            }

            if (!doValidation)
            {
                logger.logMsg(Logger.TRACEMSG, "Skipping validation of outputName=" + outputName);
                // Only bother to validate the output if asked
                return;
            }
            // If we get here, attempt to validate the contents of
            //  the last outputFile created
            CheckService fileChecker = (CheckService)datalet.options.get("fileCheckerImpl");
            // Supply default value
            if (null == fileChecker)
                fileChecker = new XHTFileCheckService();
            fileChecker.check(logger,
                              new File(outputName),
                              new File(datalet.goldName),
                              getDescription() + " " + datalet.getDescription());
        }
        // Note that this class can only validate positive test
        //  cases - we don't handle ExpectedExceptions
        catch (Throwable t)
        {
            // Put the logThrowable first, so it appears before
            //  the Fail record, and gets color-coded
            logger.logThrowable(Logger.ERRORMSG, t, "New stylesheet of: " + datalet.getDescription());
            logger.checkFail("New stylesheet of: " + datalet.getDescription()
                             + " threw: " + t.toString());
        }
    }

}  // end of class ThreadedStylesheetTestlet