/*   Copyright 2004 The Apache Software Foundation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package tools.JUnit;

import junit.runner.BaseTestRunner;
import junit.runner.TestRunListener;
import junit.framework.*;

import java.io.*;
import java.util.*;

import org.apache.xmlbeans.impl.tool.CommandLine;

public class JUnitXRunner extends BaseTestRunner
        implements JUnitXResultFormatter {
    public static void main(String args[])
            throws Exception {

        File file = new File(args[0]);
        String resListener = null;
        String outFile = null;
        boolean showOutput = false;

        Collection flags = new TreeSet();
        flags.add("showoutput");

        Collection options=new TreeSet();
        options.add(JUnitXTask.resultListener);
        options.add(JUnitXTask.outFile);

        CommandLine cmdl = new CommandLine(args, flags, options);
        showOutput = cmdl.getOpt("showoutput") != null;
        resListener = cmdl.getOpt(JUnitXTask.resultListener);
        if (resListener != null) {
            outFile = cmdl.getOpt(JUnitXTask.outFile);
            if (outFile == null)
                throw new RuntimeException("No output file specified");
        }
        ArrayList files = new ArrayList();
        try {
            BufferedReader in = new BufferedReader(new FileReader(file));
            String line;
            while ((line = in.readLine()) != null)
                files.add(line);
            in.close();

        }
        catch (Exception e) {
            e.printStackTrace();
        }

        JUnitXRunner runner;
        if (resListener != null) {
            // Try to instantiate a class of resListener
            Object obj;
            try {
                Class c = Class.forName(resListener);
                obj = c.newInstance();
            }
            catch (Exception e) {
                throw new RuntimeException(e);
            }
            JUnitXResultFormatter fmt = (JUnitXResultFormatter) obj;
            runner = new JUnitXRunner(files, fmt, outFile, showOutput);
        } else
            runner = new JUnitXRunner(files, showOutput);


        int nFailureCount = runner.runTests();

        System.exit(nFailureCount);
    }

    /////////////////////////////////////////////////////////////////////////
    // Runner implementation

    ArrayList classes;
    ArrayList tests;
    int testCount = 0;
    JUnitXResultFormatter _listener = null;
    String outFile = null;
    boolean showOutput = false;

    public JUnitXRunner(ArrayList classes, boolean showOutput) {
        this.classes = classes;
        tests = new ArrayList();
        _listener = this;
        this.showOutput = showOutput;
    }

    public JUnitXRunner(ArrayList classes,
                        JUnitXResultFormatter listener,
                        String outFile,
                        boolean showOutput) {
        this.classes = classes;
        tests = new ArrayList();
        _listener = listener;
        this.outFile = outFile;
        this.showOutput = showOutput;

    }


    public int runTests() {
        collectTests();
        Iterator itr = tests.iterator();

        TestResult res = new TestResult();
        res.addListener(_listener);

        try {
            if (outFile != null) {
                FileOutputStream fos = new FileOutputStream(new File(outFile));
                _listener.setOutput(fos);
            }
        }
        catch (FileNotFoundException fnfe) {
            throw new RuntimeException("Unable to initialize output to file "
                    + outFile + "\n" + fnfe.getMessage());
        }
       
        _listener.showTestOutput(showOutput);
        _listener.startRun();
        while (itr.hasNext()) {
            Test test = (Test) itr.next();
            test.run(res);
        }
        _listener.endRun();
        return res.failureCount();
    }

    private void collectTests() {
        Iterator itr = classes.iterator();

        while (itr.hasNext()) {
            Test suite = null;
            String className = (String) itr.next();
            suite = getTest(className);

            if (suite != null && suite.countTestCases() > 0) {
                tests.addAll(getSubTests(suite));
            } else {
                //System.out.println("No tests found in " + testClassName);
                // Ignore files which are not Junit tests.
            }
        }
    }

    private Collection getSubTests(Test test) {
        Collection ret = new ArrayList();

        if (TestSuite.class.isAssignableFrom(test.getClass())) {
            Enumeration e = ((TestSuite) test).tests();
            while (e.hasMoreElements()) {
                ret.addAll(getSubTests((Test) e.nextElement()));
            }
        } else if (TestCase.class.isAssignableFrom(test.getClass())) {
            ret.add(((TestCase) test));
        } else {
            System.out.println(
                    "Could not find any tests in " + test.toString());
        }

        return ret;
    }

    // JUnitXResultFormatter Implementation
    public void startRun() {

    }

    public void endRun() {

    }

    public void setOutput(OutputStream out) {
        // Ignored. Custom ResultFormatters will use
    }

    public void showTestOutput(boolean show) {
        // Ignore. We don't capture stdout or stderr.
    }

    // TestRunListener implementation
    public void testStarted(String testName) {
        System.out.println("\nStarted: " + testName);
    }

    public void testEnded(String testName) {
        System.out.println("Ended: " + testName);
    }

    public void testFailed(int status, Test test, Throwable t) {
        if (status == TestRunListener.STATUS_FAILURE)
            System.out.println("Failure: ");
        else
            System.out.println("Error: ");

        System.out.println(getFilteredTrace(t));
    }

    protected void runFailed(String message) {
        //System.out.println("RUN had failures");
    }

    /* This is important - not setting this to false expilcitly
     * will cause Junit to create a new classloader instance for
     * every class it loads, causing a OOM sooner or later.
     *
     * @see junit.runner.BaseTestRunner#useReloadingTestSuiteLoader()
     */
    protected boolean useReloadingTestSuiteLoader() {
        return false;
    }

    private String getStackTraceAsString(Throwable t) {
        StringWriter sw = new StringWriter();
        t.printStackTrace(new PrintWriter(sw, true));

        return sw.toString();
    }
}