ozonetestrunner.java

Java的面向对象数据库系统的源代码

// You can redistribute this software and/or modify it under the terms of
// the Ozone Library License version 1 published by ozone-db.org.
//
// The original code and portions created by SMB are
// Copyright (C) 1997-2000 by SMB GmbH. All rights reserved.
//
// $Id$


package test;


import junit.framework.AssertionFailedError;
import junit.framework.Test;
import junit.framework.TestFailure;
import junit.framework.TestResult;
import junit.runner.BaseTestRunner;
import junit.runner.TestSuiteLoader;
import org.apache.log4j.*;
import org.ozoneDB.ExternalDatabase;
import org.ozoneDB.Setup;
import org.ozoneDB.util.OzoneDebugLevel;
import org.ozoneDB.tools.Install;

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


/**
 * OzoneTestRunner is the JUnit test runner for Ozone
 * environment.
 *
 * @author <a href="http://www.softwarebuero.de/">SMB</a>
 * @author <a href="mailto:[e-mail]">David Li</a>
 * @author Per Nyfelt
 * @version $Revision$Date$
 */

public class OzoneTestRunner extends BaseTestRunner {

    /**
     * log4j logger
     */
    private static Logger log = Logger.getLogger(OzoneTestRunner.class);

    private String dbUrl;
    /**
     * Print the usage of the program
     */
    private static void printUsage() {
        System.out.println("usage: ojvm "
                + OzoneTestRunner.class.getName()
                + " {-local | -remote [-host=HOST] [-port=PORT]} [-debug=LEVEL]"
                + " TestCase");
        System.exit(1);
    }

    /**
     * The database
     */
    private ExternalDatabase fDatabase;

    /**
     * whether to use remote database
     */
    private boolean isRemote = false;

    /**
     * whether to use local database
     */
    private boolean isLocal = false;

    /**
     * database server hostname
     */
    private String dbHost = "localhost";

    /**
     * database server port
     */
    private int dbPort = 3333;

    /**
     * default dir to create test database
     */
    private File localTestDir = new File(System.getProperty("java.io.tmpdir")
            + File.separator + "OzoneTest");

    /**
     * name of the test suite to run
     */
    private String testClass;

    /**
     * Constructor
     */
    private OzoneTestRunner(String[] args) {
        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("-local")) {
                isLocal = true;
            } else if (args[i].equals("-remote")) {
                isRemote = true;
            } else if (args[i].startsWith("-host=")) {
                dbHost = args[i].substring(6);
            } else if (args[i].startsWith("-port=")) {
                dbPort = Integer.parseInt(args[i].substring(6));
            } else if (args[i].startsWith("-debug=")) {
                Category.getRoot().setLevel(OzoneDebugLevel.toLevel(args[i].substring(7)));
            } else {
                testClass = args[i];
                try {
                    // make sure the test class exist, it might be a typo or bogus argument
                    this.getClass().getClassLoader().loadClass(testClass);
                } catch (ClassNotFoundException e) {
                    System.out.println(e.toString() +  " maybe a typo?");
                    printUsage();
                }

            }
        }
    }

    /**
     * initialize the database
     * @param dbURL the database url
     */
    private void initDB(String dbURL) throws Exception {
        log.debug("initDB(): open database at '" + dbURL + "'");
        fDatabase = ExternalDatabase.openDatabase(dbURL);
        fDatabase.reloadClasses();
    }

    /**
     * Initialize a remote database.
     * @param host hostname of the database machine
     * @param port port number of the db server
     */
    private void initRemoteDB(String host, int port) throws Exception {
        dbUrl = "ozonedb:remote://" + host + ":" + port;
        initDB(dbUrl);
    }

    /**
     * The test class loader for the runner.
     */
    private static TestSuiteLoader fTestSuiteLoader = new OzoneTestSuiteLoader();

    /**
     * overrideing this method from BaseTestRunner is necessary
     * because of the default behavior of getLoader creates new
     * classloader everytime it's called. This cause problem with
     * Ozone.
     */
    public TestSuiteLoader getLoader() {
        log.debug("getLoader ()");
        return fTestSuiteLoader;
    }

    /**
     * initialize a local database
     * if one doesn't exists, create it.
     */
    private void initLocalDB() throws Exception {
        localTestDir.mkdirs();
        File dbDir = File.createTempFile("OZT", null, localTestDir);
        Setup defaults = new Setup(null);
        defaults.addProperties(System.getProperties(), "ozoneDB.");
        Install.createDB(dbDir.getPath() + ".dir", defaults, new PrintWriter(System.out, true));
        dbUrl = "ozonedb:local://" + dbDir.getPath() + ".dir";
        initDB(dbUrl);
    }

    /**
     * set up the database
     */
    private void setUpDatabase() throws Exception {
        log.info("Test: remote= " + isRemote + " local= " + isLocal);
        if (isLocal)
            initLocalDB();
        else if (isRemote)
            initRemoteDB(dbHost, dbPort);
    }

    /**
     * run the test suite
     */
    private TestResult doRun() throws Exception {
        TestResult result = new TestResult();
        Test test = getTest(testClass);
        result.addListener(this);
        try {
            setUpDatabase();
            test.run(result);
        } finally {
            if (fDatabase != null)
                fDatabase.close();
        }
        return result;
    }

    /**
     * run the tests and return a report of the result
     */
    public String runTests() throws Exception {
        long startTime = System.currentTimeMillis();
        TestResult testResult = doRun();
        long endTime = System.currentTimeMillis();
        long runTime = endTime - startTime;

        String result = "Time: " + elapsedTimeAsString(runTime);
        return result + getResultInfo(testResult);
    }

    /**
     * main
     */
    public static void main(String[] args) {
        setupLogging();
        if (args.length == 0) {
            printUsage();
        }
        try {
            OzoneTestRunner runner = new OzoneTestRunner(args);
            log.info(runner.runTests());
        } catch (Exception e) {
            log.error("run fails", e);
        }
    }

    private static void setupLogging() {
        Logger logger = Logger.getLogger("test");
        logger.removeAllAppenders();
        Appender appender = new ConsoleAppender(new PatternLayout("%-6p %c{1} - %m%n"));
        appender.setName(logger.getName());
        BasicConfigurator.configure(appender);
        Category.getRoot().setLevel(Level.INFO);
    }

    public void startTest(Test test) {
        log.info("starting test: " + test);
        if (test instanceof OzoneTestCase) {
            ((OzoneTestCase) test).setDB(fDatabase);
            ((OzoneTestCase) test).setDbUrl(dbUrl);
        }
    }

    private synchronized String getResultInfo(TestResult result) {
        String info = getErrors(result);
        info += getFailures(result);
        info += getHeader(result);
        return info;
    }

    /**
     * Gathers the errors
     */
    private String getErrors(TestResult result) {
        String errors = "";
        if (result.errorCount() != 0) {
            if (result.errorCount() == 1) {
                errors += "\nThere was " + result.errorCount() + " error:\n";
            } else {
                errors += "\nThere were " + result.errorCount() + " errors:\n";
            }
            int i = 1;
            for (Enumeration e = result.errors(); e.hasMoreElements(); i++) {
                TestFailure failure = (TestFailure) e.nextElement();
                errors += i + ") " + failure.failedTest();
                errors += "\n" + filterTrace(failure.thrownException());
            }
        }
        return errors;
    }

    /**
     * Gathers the failures
     */
    private String getFailures(TestResult result) {
        String failures = "";
        if (result.failureCount() != 0) {
            if (result.failureCount() == 1) {
                failures += "\nThere was " + result.failureCount() + " failure:\n";
            } else {
                failures += "\nThere were " + result.failureCount() + " failures:\n";
            }
            int i = 1;
            for (Enumeration e = result.failures(); e.hasMoreElements(); i++) {
                TestFailure failure = (TestFailure) e.nextElement();
                failures += i + ") " + failure.failedTest();
                failures += "\n" + filterTrace(failure.thrownException());
            }
        }
        return failures;
    }

    /**
     * Create the header of the report
     */
    private String getHeader(TestResult result) {
        String header = "\n";
        if (result.wasSuccessful()) {
            header += "OK";
            header += "\n (" + result.runCount() + " tests)";

        } else {
            header += "FAILURES!!!";
            header += "Tests run: " + result.runCount() +
                    ",  Failures: " + result.failureCount() +
                    ",  Errors: " + result.errorCount();
        }
        return header;
    }

    /**
     * Returns a filtered stack trace
     */
    public String filterTrace(Throwable t) {
        StringWriter stringWriter = new StringWriter();
        PrintWriter writer = new PrintWriter(stringWriter);
        t.printStackTrace(writer);

        StringBuffer buffer = stringWriter.getBuffer();
        String trace = buffer.toString();

        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        BufferedReader br = new BufferedReader(new StringReader(trace));

        String line;
        try {
            while ((line = br.readLine()) != null) {
                if (!filterNoice(line))
                    pw.println(line);
            }
        } catch (Exception IOException) {
            return trace; // return the stack unfiltered
        }
        return sw.toString();
    }

    /**
     *  Filter out unwanted noice from the testing framework iteself
     */
    private boolean filterNoice(String line) {
        final String[] patterns = new String[]{
            "junit.framework.TestResult",
            "junit.framework.TestSuite",
            "junit.framework.TestCase",
            "junit.framework.Assert.", // don't filter AssertionFailure
            "junit.textui.TestRunner",
            "java.lang.reflect.Method.invoke(",
            "sun.reflect.",
            "test.OzoneTestRunner"
        };
        for (int i = 0; i < patterns.length; i++) {
            if (line.indexOf(patterns[i]) > 0)
                return true;
        }
        return false;
    }

    // todo check to see if we need to something for these methods
    public void testStarted(String s) {
    }

    public void testEnded(String s) {
    }

    public void testFailed(int i, Test test, Throwable throwable) {
    }

    public void addError(Test test, Throwable throwable) {
    }

    public void addFailure(Test test, AssertionFailedError error) {
    }

    public void endTest(Test test) {
    }

    protected void runFailed(String s) {
    }
}