test/java/src/org/apache/qetest/xsl/ThreadedStylesheetTestlet.java - platform/external/apache-xml - Git at Google

 /*
  * 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
	/*
	* 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