/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */
package org.apache.qpid.junit.extensions;

import junit.framework.Test;
import junit.framework.TestResult;
import junit.framework.TestSuite;

import org.apache.log4j.Logger;

import org.apache.qpid.junit.extensions.listeners.CSVTestListener;
import org.apache.qpid.junit.extensions.listeners.ConsoleTestListener;
import org.apache.qpid.junit.extensions.listeners.XMLTestListener;
import org.apache.qpid.junit.extensions.util.CommandLineParser;
import org.apache.qpid.junit.extensions.util.MathUtils;
import org.apache.qpid.junit.extensions.util.ParsedProperties;
import org.apache.qpid.junit.extensions.util.TestContextProperties;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

/**
 * TKTestRunner extends {@link junit.textui.TestRunner} with the ability to run tests multiple times, to execute a test
 * simultaneously using many threads, to put a delay between test runs and adds support for tests that take integer
 * parameters that can be 'stepped' through on multiple test runs. These features can be accessed by using this class
 * as an entry point and passing command line arguments to specify which features to use:
 *
 * <pre>
 * -w ms       The number of milliseconds between invocations of test cases.
 * -c pattern  The number of tests to run concurrently.
 * -r num      The number of times to repeat each test.
 * -d duration The length of time to run the tests for.
 * -t name     The name of the test case to execute.
 * -s pattern  The size parameter to run tests with.
 * -o dir      The name of the directory to output test timings to.
 * --csv       Output test results in CSV format.
 * --xml       Output test results in XML format.
 * </pre>
 *
 * <p/>This command line may also have trailing 'name=value' parameters added to it. All of these values are added
 * to the test context properties and passed to the test, which can access them by name.
 *
 * <p/>The pattern arguments are of the form [lowest(: ...)(: highest)](:sample=s)(:exp), where round brackets
 * enclose optional values. Using this pattern form it is possible to specify a single value, a range of values divided
 * into s samples, a range of values divided into s samples but distributed exponentially, or a fixed set of samples.
 *
 * <p/>The duration arguments are of the form (dD)(hH)(mM)(sS), where round brackets enclose optional values. At least
 * one of the optional values must be present.
 *
 * <p/>When specifying optional test parameters on the command line, in 'name=value' format, it is also possible to use
 * the format 'name=[value1:value2:value3:...]', to specify multiple values for a parameter. All permutations of all
 * parameters with multiple values will be created and tested. If the values are numerical, it is also possible to use
 * the sequence generation patterns instead of fully specifying all of the values.
 *
 * <p/>Here are some examples:
 *
 * <p/><table>
 * <tr><td><pre> -c [10:20:30:40:50] </pre><td> Runs the test with 10,20,...,50 threads.
 * <tr><td><pre> -s [1:100]:samples=10 </pre>
 *     <td> Runs the test with ten different size parameters evenly spaced between 1 and 100.
 * <tr><td><pre> -s [1:1000000]:samples=10:exp </pre>
 *     <td> Runs the test with ten different size parameters exponentially spaced between 1 and 1000000.
 * <tr><td><pre> -r 10 </pre><td> Runs each test ten times.
 * <tr><td><pre> -d 10H </pre><td> Runs the test repeatedly for 10 hours.
 * <tr><td><pre> -d 1M, -r 10 </pre>
 *     <td> Runs the test repeatedly for 1 minute but only takes a timing sample every 10 test runs.
 * <tr><td><pre> -r 10, -c [1:5:10:50], -s [100:1000:10000] </pre>
 *     <td> Runs 12 test cycles (4 concurrency samples * 3 size sample), with 10 repeats each. In total the test
 *          will be run 199 times (3 + 15 + 30 + 150)
 * <tr><td><pre> cache=true </pre><td> Passes the 'cache' parameter with value 'true' to the test.
 * <tr><td><pre> cache=[true:false] </pre><td> Runs the test with the 'cache' parameter set to 'true' and 'false'.
 * <tr><td><pre> cacheSize=[1000:1000000],samples=4,exp </pre>
 *     <td> Runs the test with the 'cache' parameter set to a series of exponentially increasing sizes.
 * </table>
 *
 * <p><table id="crc"><caption>CRC Card</caption>
 * <tr><th> Responsibilities <th> Collaborations
 * <tr><td> Create the test configuration specified by the command line parameters.
 * </table>
 *
 * @todo Verify that the output directory exists or can be created.
 *
 * @todo Verify that the specific named test case to execute exists.
 *
 * @todo Drop the delay parameter as it is being replaced by throttling.
 *
 * @todo Completely replace the test ui test runner, instead of having TKTestRunner inherit from it, its just not
 *       good code to extend.
 *
 * @author Rupert Smith
 */
public class TKTestRunner extends TestRunnerImprovedErrorHandling
{
    /** Used for debugging. */
    private static final Logger log = Logger.getLogger(TKTestRunner.class);

    /** Used for displaying information on the console. */
    // private static final Logger console = Logger.getLogger("CONSOLE." + TKTestRunner.class.getName());

    /** Used for generating the timestamp when naming output files. */
    protected static final DateFormat TIME_STAMP_FORMAT = new SimpleDateFormat("yyyy-MM-dd-HH.mm.ss");

    /** Number of times to rerun the test. */
    protected Integer repetitions = 1;

    /** The length of time to run the tests for. */
    protected Long duration;

    /** Number of threads running the tests. */
    protected int[] threads;

    /** Delay in ms to wait between two test cases. */
    protected int delay = 0;

    /** The parameter values to pass to parameterized tests. */
    protected int[] params;

    /** Name of the single test case to execute. */
    protected String testCaseName = null;

    /** Name of the test class. */
    protected String testClassName = null;

    /** Name of the test run. */
    protected String testRunName = null;

    /** Directory to output XML reports into, if specified. */
    protected String reportDir = null;

    /** Flag that indicates the CSV results listener should be used to output results. */
    protected boolean csvResults;

    /** Flag that indiciates the XML results listener should be used to output results. */
    protected boolean xmlResults;

    /**
     * Holds the name of the class of the test currently being run. Ideally passed into the {@link #createTestResult}
     * method, but as the signature is already fixed for this, the current value gets pushed here as a member variable.
     */
    protected String currentTestClassName;

    /** Holds the test results object, which is reponsible for instrumenting tests/threads to record results. */
    protected TKTestResult result;

    /** Holds a list of factories for instantiating optional user specified test decorators. */
    protected List<TestDecoratorFactory> decoratorFactories;

    /**
     * Constructs a TKTestRunner using System.out for all the output.
     *
     * @param repetitions        The number of times to repeat the test, or test batch size.
     * @param duration           The length of time to run the tests for. -1 means no duration has been set.
     * @param threads            The concurrency levels to ramp up to.
     * @param delay              A delay in milliseconds between test runs.
     * @param params             The sets of 'size' parameters to pass to test.
     * @param testCaseName       The name of the test case to run.
     * @param reportDir          The directory to output the test results to.
     * @param runName            The name of the test run; used to name the output file.
     * @param csvResults         <tt>true</tt> if the CSV results listener should be attached.
     * @param xmlResults         <tt>true</tt> if the XML results listener should be attached.
     * @param decoratorFactories List of factories for user specified decorators.
     */
    public TKTestRunner(Integer repetitions, Long duration, int[] threads, int delay, int[] params, String testCaseName,
        String reportDir, String runName, boolean csvResults, boolean xmlResults,
        List<TestDecoratorFactory> decoratorFactories)
    {
        super(new NullResultPrinter(System.out));

        log.debug("public TKTestRunner(): called");

        // Keep all the test parameters.
        this.repetitions = repetitions;
        this.duration = duration;
        this.threads = threads;
        this.delay = delay;
        this.params = params;
        this.testCaseName = testCaseName;
        this.reportDir = reportDir;
        this.testRunName = runName;
        this.csvResults = csvResults;
        this.xmlResults = xmlResults;
        this.decoratorFactories = decoratorFactories;
    }

    /**
     * The entry point for the toolkit test runner.
     *
     * @param args The command line arguments.
     */
    public static void main(String[] args)
    {
        // Use the command line parser to evaluate the command line.
        CommandLineParser commandLine =
            new CommandLineParser(
                new String[][]
                {
                    { "w", "The number of milliseconds between invocations of test cases.", "ms", "false" },
                    { "c", "The number of tests to run concurrently.", "num", "false", MathUtils.SEQUENCE_REGEXP },
                    { "r", "The number of times to repeat each test.", "num", "false" },
                    { "d", "The length of time to run the tests for.", "duration", "false", MathUtils.DURATION_REGEXP },
                    { "f", "The maximum rate to call the tests at.", "frequency", "false", "^([1-9][0-9]*)/([1-9][0-9]*)$" },
                    { "s", "The size parameter to run tests with.", "size", "false", MathUtils.SEQUENCE_REGEXP },
                    { "t", "The name of the test case to execute.", "name", "false" },
                    { "o", "The name of the directory to output test timings to.", "dir", "false" },
                    { "n", "A name for this test run, used to name the output file.", "name", "true" },
                    {
                        "X:decorators", "A list of additional test decorators to wrap the tests in.",
                        "\"class.name[:class.name]*\"", "false"
                    },
                    { "1", "Test class.", "class", "true" },
                    { "-csv", "Output test results in CSV format.", null, "false" },
                    { "-xml", "Output test results in XML format.", null, "false" }
                });

        // Capture the command line arguments or display errors and correct usage and then exit.
        ParsedProperties options = null;

        try
        {
            options = new ParsedProperties(commandLine.parseCommandLine(args));
        }
        catch (IllegalArgumentException e)
        {
            System.out.println(commandLine.getErrors());
            System.out.println(commandLine.getUsage());
            System.exit(FAILURE_EXIT);
        }

        // Extract the command line options.
        Integer delay = options.getPropertyAsInteger("w");
        String threadsString = options.getProperty("c");
        Integer repetitions = options.getPropertyAsInteger("r");
        String durationString = options.getProperty("d");
        String paramsString = options.getProperty("s");
        String testCaseName = options.getProperty("t");
        String reportDir = options.getProperty("o");
        String testRunName = options.getProperty("n");
        String decorators = options.getProperty("X:decorators");
        String testClassName = options.getProperty("1");
        boolean csvResults = options.getPropertyAsBoolean("-csv");
        boolean xmlResults = options.getPropertyAsBoolean("-xml");

        int[] threads = (threadsString == null) ? null : MathUtils.parseSequence(threadsString);
        int[] params = (paramsString == null) ? null : MathUtils.parseSequence(paramsString);
        Long duration = (durationString == null) ? null : MathUtils.parseDuration(durationString);

        // The test run name defaults to the test class name unless a value was specified for it.
        testRunName = (testRunName == null) ? testClassName : testRunName;

        // Add all the command line options and trailing settings to test context properties. Tests may pick up
        // overridden values from there, and these values will be logged in the test results, for analysis and
        // to make tests repeatable.
        commandLine.addTrailingPairsToProperties(TestContextProperties.getInstance());
        commandLine.addOptionsToProperties(TestContextProperties.getInstance());

        // Create and start the test runner.
        try
        {
            // Create a list of test decorator factories for use specified decorators to be applied.
            List<TestDecoratorFactory> decoratorFactories = parseDecorators(decorators);

            TKTestRunner testRunner =
                new TKTestRunner(repetitions, duration, threads, (delay == null) ? 0 : delay, params, testCaseName,
                    reportDir, testRunName, csvResults, xmlResults, decoratorFactories);

            TestResult testResult = testRunner.start(testClassName);

            if (!testResult.wasSuccessful())
            {
                System.exit(FAILURE_EXIT);
            }
        }
        catch (Exception e)
        {
            System.err.println(e.getMessage());
            e.printStackTrace(new PrintStream(System.err));
            System.exit(EXCEPTION_EXIT);
        }
    }

    /**
     * Parses a list of test decorators, in the form "class.name[:class.name]*", and creates factories for those
     * TestDecorator classes , and returns a list of the factories. This list of factories will be in the same
     * order as specified in the string. The factories can be used to succesively wrap tests in layers of
     * decorators, as decorators themselves implement the 'Test' interface.
     *
     * <p/>If the string fails to parse, or if any of the decorators specified in it are cannot be loaded, or are not
     * TestDecorators, a runtime exception with a suitable error message will be thrown. The factories themselves
     * throw runtimes if the constructor method calls on the decorators fail.
     *
     * @param decorators The decorators list to be parsed.
     *
     * @return A list of instantiated decorators.
     */
    protected static List<TestDecoratorFactory> parseDecorators(String decorators)
    {
        List<TestDecoratorFactory> result = new LinkedList<TestDecoratorFactory>();
        String toParse = decorators;

        // Check that the decorators string is not null or empty, returning an empty list of decorator factories it
        // it is.
        if ((decorators == null) || "".equals(decorators))
        {
            return result;
        }

        // Strip any leading and trailing quotes from the string.
        if (toParse.charAt(0) == '\"')
        {
            toParse = toParse.substring(1, toParse.length() - 1);
        }

        if (toParse.charAt(toParse.length() - 1) == '\"')
        {
            toParse = toParse.substring(0, toParse.length() - 2);
        }

        // Instantiate all decorators.
        for (String decoratorClassName : toParse.split(":"))
        {
            try
            {
                Class decoratorClass = Class.forName(decoratorClassName);
                final Constructor decoratorConstructor = decoratorClass.getConstructor(WrappedSuiteTestDecorator.class);

                // Check that the decorator is an instance of WrappedSuiteTestDecorator.
                if (!WrappedSuiteTestDecorator.class.isAssignableFrom(decoratorClass))
                {
                    throw new RuntimeException("The decorator class " + decoratorClassName
                        + " is not a sub-class of WrappedSuiteTestDecorator, which it needs to be.");
                }

                result.add(new TestDecoratorFactory()
                    {
                        public WrappedSuiteTestDecorator decorateTest(Test test)
                        {
                            try
                            {
                                return (WrappedSuiteTestDecorator) decoratorConstructor.newInstance(test);
                            }
                            catch (InstantiationException e)
                            {
                                throw new RuntimeException(
                                    "The decorator class " + decoratorConstructor.getDeclaringClass().getName()
                                    + " cannot be instantiated.", e);
                            }
                            catch (IllegalAccessException e)
                            {
                                throw new RuntimeException(
                                    "The decorator class " + decoratorConstructor.getDeclaringClass().getName()
                                    + " does not have a publicly accessable constructor.", e);
                            }
                            catch (InvocationTargetException e)
                            {
                                throw new RuntimeException(
                                    "The decorator class " + decoratorConstructor.getDeclaringClass().getName()
                                    + " cannot be invoked.", e);
                            }
                        }
                    });
            }
            catch (ClassNotFoundException e)
            {
                throw new RuntimeException("The decorator class " + decoratorClassName + " could not be found.", e);
            }
            catch (NoSuchMethodException e)
            {
                throw new RuntimeException("The decorator class " + decoratorClassName
                    + " does not have a constructor that accepts a single 'WrappedSuiteTestDecorator' argument.", e);
            }
        }

        return result;
    }

    /**
     * TestDecoratorFactory is a factory for creating test decorators from tests.
     */
    protected interface TestDecoratorFactory
    {
        /**
         * Decorates the specified test with a new decorator.
         *
         * @param test The test to decorate.
         *
         * @return The decorated test.
         */
        public WrappedSuiteTestDecorator decorateTest(Test test);
    }

    /**
     * Runs a test or suite of tests, using the super class implemenation. This method wraps the test to be run
     * in any test decorators needed to add in the configured toolkits enhanced junit functionality.
     *
     * @param test The test to run.
     * @param wait Undocumented. Nothing in the JUnit javadocs to say what this is for.
     *
     * @return The results of the test run.
     */
    public TestResult doRun(Test test, boolean wait)
    {
        log.debug("public TestResult doRun(Test \"" + test + "\", boolean " + wait + "): called");

        // Wrap the tests in decorators for duration, scaling, repetition, parameterization etc.
        WrappedSuiteTestDecorator targetTest = decorateTests(test);

        // Delegate to the super method to run the decorated tests.
        log.debug("About to call super.doRun");

        TestResult result = super.doRun(targetTest, wait);
        log.debug("super.doRun returned.");

        /*if (result instanceof TKTestResult)
        {
            TKTestResult tkResult = (TKTestResult) result;

            tkResult.notifyEndBatch();
        }*/

        return result;
    }

    /**
     * Applies test decorators to the tests for parameterization, duration, scaling and repetition.
     *
     * @param test The test to decorat.
     *
     * @return The decorated test.
     */
    protected WrappedSuiteTestDecorator decorateTests(Test test)
    {
        log.debug("params = " + ((params == null) ? null : MathUtils.printArray(params)));
        log.debug("repetitions = " + repetitions);
        log.debug("threads = " + ((threads == null) ? null : MathUtils.printArray(threads)));
        log.debug("duration = " + duration);

        // Wrap all tests in the test suite with WrappedSuiteTestDecorators. This is quite ugly and a bit baffling,
        // but the reason it is done is because the JUnit implementation of TestDecorator has some bugs in it.
        WrappedSuiteTestDecorator targetTest = null;

        if (test instanceof TestSuite)
        {
            log.debug("targetTest is a TestSuite");

            TestSuite suite = (TestSuite) test;

            int numTests = suite.countTestCases();
            log.debug("There are " + numTests + " in the suite.");

            for (int i = 0; i < numTests; i++)
            {
                Test nextTest = suite.testAt(i);
                log.debug("suite.testAt(" + i + ") = " + nextTest);

                if (nextTest instanceof TimingControllerAware)
                {
                    log.debug("nextTest is TimingControllerAware");
                }

                if (nextTest instanceof TestThreadAware)
                {
                    log.debug("nextTest is TestThreadAware");
                }
            }

            targetTest = new WrappedSuiteTestDecorator(suite);
            log.debug("Wrapped with a WrappedSuiteTestDecorator.");
        }
        // If the test has already been wrapped, no need to do it again.
        else if (test instanceof WrappedSuiteTestDecorator)
        {
            targetTest = (WrappedSuiteTestDecorator) test;
        }

        // If size parameter values have been set, then wrap the test in an asymptotic test decorator.
        if (params != null)
        {
            targetTest = new AsymptoticTestDecorator(targetTest, params, (repetitions == null) ? 1 : repetitions);
            log.debug("Wrapped with asymptotic test decorator.");
            log.debug("targetTest = " + targetTest);
        }

        // If no size parameters are set but the repitions parameter is, then wrap the test in an asymptotic test decorator.
        else if ((repetitions != null) && (repetitions > 1))
        {
            targetTest = new AsymptoticTestDecorator(targetTest, new int[] { 1 }, repetitions);
            log.debug("Wrapped with asymptotic test decorator.");
            log.debug("targetTest = " + targetTest);
        }

        // Apply any optional user specified decorators.
        targetTest = applyOptionalUserDecorators(targetTest);

        // If a test run duration has been set then wrap the test in a duration test decorator. This will wrap on
        // top of size, repeat or concurrency wrappings already applied.
        if (duration != null)
        {
            DurationTestDecorator durationTest = new DurationTestDecorator(targetTest, duration);
            targetTest = durationTest;

            log.debug("Wrapped with duration test decorator.");
            log.debug("targetTest = " + targetTest);

            registerShutdownHook(durationTest);
        }

        // ParameterVariationTestDecorator...

        // If a test thread concurrency level is set then wrap the test in a scaled test decorator. This will wrap on
        // top of size scaling or repetition wrappings.
        ScaledTestDecorator scaledDecorator;

        if ((threads != null) && ((threads.length > 1) || (MathUtils.maxInArray(threads) > 1)))
        {
            scaledDecorator = new ScaledTestDecorator(targetTest, threads);
            targetTest = scaledDecorator;
            log.debug("Wrapped with scaled test decorator.");
            log.debug("targetTest = " + targetTest);
        }
        else
        {
            scaledDecorator = new ScaledTestDecorator(targetTest, new int[] { 1 });
            targetTest = scaledDecorator;
            log.debug("Wrapped with scaled test decorator with default of 1 thread.");
            log.debug("targetTest = " + targetTest);
        }

        // Register the scaled test decorators shutdown hook.
        registerShutdownHook(scaledDecorator);

        return targetTest;
    }

    /**
     * If there were any user specified test decorators on the command line, this method instantiates them and wraps
     * the test in them, from inner-most to outer-most in the order in which the decorators were supplied on the
     * command line.
     *
     * @param targetTest The test to wrap.
     *
     * @return A wrapped test.
     */
    protected WrappedSuiteTestDecorator applyOptionalUserDecorators(WrappedSuiteTestDecorator targetTest)
    {
        // If there are user defined test decorators apply them in order now.
        for (TestDecoratorFactory factory : decoratorFactories)
        {
            targetTest = factory.decorateTest(targetTest);
        }

        return targetTest;
    }

    /**
     * Creates the TestResult object to be used for test runs. See {@link TKTestResult} for more information and the
     * enhanced test result class that this uses.
     *
     * @return An instance of the enhanced test result object, {@link TKTestResult}.
     */
    protected TestResult createTestResult()
    {
        log.debug("protected TestResult createTestResult(): called");

        TKTestResult result = new TKTestResult(delay, testCaseName);

        // Check if a directory to output reports to has been specified and attach test listeners if so.
        if (reportDir != null)
        {
            // Create the report directory if it does not already exist.
            File reportDirFile = new File(reportDir);

            if (!reportDirFile.exists())
            {
                reportDirFile.mkdir();
            }

            // Create the results file (make the name of this configurable as a command line parameter).
            Writer timingsWriter;

            // Always set up a console feedback listener.
            ConsoleTestListener feedbackListener = new ConsoleTestListener();
            result.addListener(feedbackListener);
            result.addTKTestListener(feedbackListener);

            // Set up an XML results listener to output the timings to the results file, if requested on the command line.
            if (xmlResults)
            {
                try
                {
                    File timingsFile = new File(reportDirFile, "TEST-" + currentTestClassName + ".xml");
                    timingsWriter = new BufferedWriter(new FileWriter(timingsFile), 20000);
                }
                catch (IOException e)
                {
                    throw new RuntimeException("Unable to create the log file to write test results to: " + e, e);
                }

                XMLTestListener listener = new XMLTestListener(timingsWriter, currentTestClassName);
                result.addListener(listener);
                result.addTKTestListener(listener);

                registerShutdownHook(listener);
            }

            // Set up an CSV results listener to output the timings to the results file, if requested on the command line.
            if (csvResults)
            {
                try
                {
                    File timingsFile =
                        new File(reportDirFile, testRunName + "-" + TIME_STAMP_FORMAT.format(new Date()) + "-timings.csv");
                    timingsWriter = new BufferedWriter(new FileWriter(timingsFile), 20000);
                }
                catch (IOException e)
                {
                    throw new RuntimeException("Unable to create the log file to write test results to: " + e, e);
                }

                CSVTestListener listener = new CSVTestListener(timingsWriter);
                result.addListener(listener);
                result.addTKTestListener(listener);

                // Register the results listeners shutdown hook to flush its data if the test framework is shutdown
                // prematurely.
                registerShutdownHook(listener);
            }

            // Register the results listeners shutdown hook to flush its data if the test framework is shutdown
            // prematurely.
            // registerShutdownHook(listener);

            // Record the start time of the batch.
            // result.notifyStartBatch();

            // At this point in time the test class has been instantiated, giving it an opportunity to read its parameters.
            // Inform any test listers of the test properties.
            result.notifyTestProperties(TestContextProperties.getAccessedProps());
        }

        return result;
    }

    /**
     * Registers the shutdown hook of a {@link ShutdownHookable}.
     *
     * @param hookable The hookable to register.
     */
    protected void registerShutdownHook(ShutdownHookable hookable)
    {
        Runtime.getRuntime().addShutdownHook(hookable.getShutdownHook());
    }

    /**
     * Initializes the test runner with the provided command line arguments and and starts the test run.
     *
     * @param testClassName The fully qualified name of the test class to run.
     *
     * @return The test results.
     *
     * @throws Exception Any exceptions from running the tests are allowed to fall through.
     */
    protected TestResult start(String testClassName) throws Exception
    {
        // Record the current test class, so that the test results can be output to a file incorporating this name.
        this.currentTestClassName = testClassName;

        // Delegate to the super method to run the tests.
        return super.start(new String[] { testClassName });
    }
}