xmlunitresultformatter.java

MoMEUnit是一个单元测试的J2ME的应用程序xUnit架构实例。这是来自JUnit框架

package org.momeunit.ant.formatter;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.Hashtable;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.util.DOMElementWriter;
import org.momeunit.ant.core.Utility;
import org.momeunit.ant.core.XMLConstants;
import org.momeunit.ant.event.TestEvent;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Predefined <code>xml</code> formatter. Generates report in xml format. It
 * fully resembles functionality of it's <code>&lt;junit&gt;</code> analog and
 * produces report of the same format.
 * 
 * @author Sergio Morozov
 * @version 1.1.2
 */
public class XMLUnitResultFormatter extends UnitResultFormatter implements
    XMLConstants
{

  private static DocumentBuilder getDocumentBuilder()
  {
    try
    {
      return DocumentBuilderFactory.newInstance().newDocumentBuilder();
    } catch (Exception exc)
    {
      throw new ExceptionInInitializerError(exc);
    }
  }

  private Hashtable failedTests = new Hashtable();

  private Hashtable errorTests = new Hashtable();

  private Hashtable testsTime = new Hashtable();

  /**
   * Test suite time.
   */
  private double suiteTime = 0.0;

  /**
   * DOM Document
   */
  private Document doc;

  /**
   * The wrapper for the whole testsuite.
   */
  private Element rootElement;

  /*
   * (non-Javadoc)
   * 
   * @see UnitResultFormatter#startTestSuite(java.lang.String)
   */
  public void startTestSuite(String name)
  {
    super.startTestSuite(name);
    doc = getDocumentBuilder().newDocument();
    rootElement = doc.createElement(TESTSUITE);
    rootElement.setAttribute(ATTR_NAME, getTestSuiteName());

    Element propsElement = doc.createElement(PROPERTIES);
    rootElement.appendChild(propsElement);
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.momeunit.ant.formatter.UnitResultFormatter#endTestSuite()
   */
  public void endTestSuite() throws BuildException
  {
    OutputStream out = this.getOutput();
    if (out != null)
    {
      rootElement.setAttribute(ATTR_TESTS, Integer.toString(this.testsTime
          .size()));
      rootElement.setAttribute(ATTR_FAILURES, Integer.toString(this.failedTests
          .size()));
      rootElement.setAttribute(ATTR_ERRORS, Integer.toString(this.errorTests
          .size()));
      rootElement.setAttribute(ATTR_TIME, Utility.formatTime(this.suiteTime));
      BufferedWriter writer = null;
      try
      {
        writer = new BufferedWriter(new OutputStreamWriter(out, getEncoding()));
        writer.write("<?xml version=\"1.0\" encoding=\"" + getEncoding()
            + "\" ?>\n");
        (new DOMElementWriter()).write(rootElement, writer, 0, "  ");
        writer.flush();
      } catch (IOException err)
      {
        throw new BuildException("Unable to write log file", err);
      } finally
      {
        if (out != System.out && out != System.err)
        {
          if (writer != null)
          {
            try
            {
              writer.close();
            } catch (IOException e)
            {}
          }
        }
      }
    }
  }

  /**
   * Generates an error element described by the given type and test event.
   * 
   * @param type
   *          type of error. Either error or failure.
   * @param event
   * 
   * @param cur
   *          DOM element where to append generated error element.
   */
  private void formatError(String type, TestEvent event, Element cur)
  {
    Element err = doc.createElement(type);
    cur.appendChild(err);
    String message = event.getMsg();
    if (message != null && message.length() > 0) err.setAttribute(ATTR_MESSAGE,
        message);
    err.setAttribute(ATTR_TYPE, event.getErrorClassName());
    String stackTrace = event.getStackTrace();
    if (isFilterTrace()) stackTrace = filterStackTrace(stackTrace);
    err.appendChild(doc.createTextNode(stackTrace));
  }

  /*
   * (non-Javadoc)
   * 
   * @see TestEventListener#addError(TestEvent)
   */
  public void addError(TestEvent event)
  {
    String testName = event.getTestName();
    this.errorTests.put(testName, event);
    this.testsTime.put(testName, new Long(event.getTimestamp()
        - ((Long) this.testsTime.get(testName)).longValue()));
  }

  /*
   * (non-Javadoc)
   * 
   * @see TestEventListener#addFailure(TestEvent)
   */
  public void addFailure(TestEvent event)
  {
    String testName = event.getTestName();
    failedTests.put(testName, event);
    this.testsTime.put(testName, new Long(event.getTimestamp()
        - ((Long) this.testsTime.get(testName)).longValue()));
  }

  /*
   * (non-Javadoc)
   * 
   * @see TestEventListener#endTest(TestEvent)
   */
  public void endTest(TestEvent event)
  {
    String name = event.getTestName();
    double time = 0.0;
    if (this.errorTests.containsKey(name) || this.failedTests.containsKey(name)) time = ((Long) this.testsTime
        .get(name)).longValue() / 1000.0;
    else time = (event.getTimestamp() - (((Long) this.testsTime.get(name))
        .longValue())) / 1000.0;
    this.suiteTime += time;

    Element testElement = doc.createElement(TESTCASE);

    testElement.setAttribute(ATTR_NAME, name);
    testElement.setAttribute(ATTR_CLASSNAME, event.getTestClassName());
    testElement.setAttribute(ATTR_TIME, Utility.formatTime(time));
    rootElement.appendChild(testElement);

    if (this.failedTests.containsKey(name)) formatError(FAILURE,
        (TestEvent) this.failedTests.get(name), testElement);
    else if (this.errorTests.containsKey(name)) formatError(ERROR,
        (TestEvent) this.errorTests.get(name), testElement);
  }

  /*
   * (non-Javadoc)
   * 
   * @see TestEventListener#startTest(TestEvent)
   */
  public void startTest(TestEvent event)
  {
    this.testsTime.put(event.getTestName(), new Long(event.getTimestamp()));
  }
}