/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001-2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Ant", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.tools.ant.taskdefs.optional.junit;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.FileOutputStream;
import java.util.Enumeration;
import java.util.Vector;
import org.w3c.dom.Element;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.DirectoryScanner;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.types.FileSet;
import org.apache.tools.ant.util.DOMElementWriter;
import org.apache.tools.ant.util.StringUtils;
/**
* Aggregates all <junit> XML formatter testsuite data under
* a specific directory and transforms the results via XSLT.
* It is not particulary clean but
* should be helpful while I am thinking about another technique.
*
* <p> The main problem is due to the fact that a JVM can be forked for a testcase
* thus making it impossible to aggregate all testcases since the listener is
* (obviously) in the forked JVM. A solution could be to write a
* TestListener that will receive events from the TestRunner via sockets. This
* is IMHO the simplest way to do it to avoid this file hacking thing.
*
* @author <a href="mailto:sbailliez@imediation.com">Stephane Bailliez</a>
*
* @ant.task name="junitreport" category="testing"
*/
public class XMLResultAggregator extends Task implements XMLConstants {
/** the list of all filesets, that should contains the xml to aggregate */
protected Vector filesets = new Vector();
/** the name of the result file */
protected String toFile;
/** the directory to write the file to */
protected File toDir;
protected Vector transformers = new Vector();
/** The default directory: <tt>.</tt>. It is resolved from the project directory */
public static final String DEFAULT_DIR = ".";
/** the default file name: <tt>TESTS-TestSuites.xml</tt> */
public static final String DEFAULT_FILENAME = "TESTS-TestSuites.xml";
/**
* Generate a report based on the document created by the merge.
*/
public AggregateTransformer createReport(){
AggregateTransformer transformer = new AggregateTransformer(this);
transformers.addElement(transformer);
return transformer;
}
/**
* Set the name of the aggregegated results file. It must be relative
* from the <tt>todir</tt> attribute. If not set it will use {@link #DEFAULT_FILENAME}
* @param value the name of the file.
* @see #setTodir(File)
*/
public void setTofile(String value){
toFile = value;
}
/**
* Set the destination directory where the results should be written. If not
* set if will use {@link #DEFAULT_DIR}. When given a relative directory
* it will resolve it from the project directory.
* @param value the directory where to write the results, absolute or
* relative.
*/
public void setTodir(File value){
toDir = value;
}
/**
* Add a new fileset containing the XML results to aggregate
* @param fs the new fileset of xml results.
*/
public void addFileSet(FileSet fs) {
filesets.addElement(fs);
}
/**
* Aggregate all testsuites into a single document and write it to the
* specified directory and file.
* @throws BuildException thrown if there is a serious error while writing
* the document.
*/
public void execute() throws BuildException {
Element rootElement = createDocument();
File destFile = getDestinationFile();
// write the document
try {
writeDOMTree(rootElement.getOwnerDocument(), destFile);
} catch (IOException e){
throw new BuildException("Unable to write test aggregate to '" + destFile + "'", e);
}
// apply transformation
Enumeration enum = transformers.elements();
while (enum.hasMoreElements()) {
AggregateTransformer transformer =
(AggregateTransformer) enum.nextElement();
transformer.setXmlDocument(rootElement.getOwnerDocument());
transformer.transform();
}
}
/**
* Get the full destination file where to write the result. It is made of
* the <tt>todir</tt> and <tt>tofile</tt> attributes.
* @return the destination file where should be written the result file.
*/
protected File getDestinationFile(){
if (toFile == null){
toFile = DEFAULT_FILENAME;
}
if (toDir == null){
toDir = project.resolveFile(DEFAULT_DIR);
}
return new File(toDir, toFile);
}
/**
* Get all <code>.xml</code> files in the fileset.
*
* @return all files in the fileset that end with a '.xml'.
*/
protected File[] getFiles() {
Vector v = new Vector();
final int size = filesets.size();
for (int i = 0; i < size; i++) {
FileSet fs = (FileSet) filesets.elementAt(i);
DirectoryScanner ds = fs.getDirectoryScanner(project);
ds.scan();
String[] f = ds.getIncludedFiles();
for (int j = 0; j < f.length; j++) {
String pathname = f[j];
if (pathname.endsWith(".xml")) {
File file = new File(ds.getBasedir(), pathname);
file = project.resolveFile(file.getPath());
v.addElement(file);
}
}
}
File[] files = new File[v.size()];
v.copyInto(files);
return files;
}
//----- from now, the methods are all related to DOM tree manipulation
/**
* Write the DOM tree to a file.
* @param doc the XML document to dump to disk.
* @param file the filename to write the document to. Should obviouslly be a .xml file.
* @throws IOException thrown if there is an error while writing the content.
*/
protected void writeDOMTree(Document doc, File file) throws IOException {
OutputStream out = null;
PrintWriter wri = null;
try {
out = new FileOutputStream(file);
wri = new PrintWriter(new OutputStreamWriter(out, "UTF8"));
wri.write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
(new DOMElementWriter()).write(doc.getDocumentElement(), wri, 0, " ");
wri.flush();
// writers do not throw exceptions, so check for them.
if (wri.checkError()){
throw new IOException("Error while writing DOM content");
}
} finally {
if (wri != null) {
wri.close();
out = null;
}
if (out != null) {
out.close();
}
}
}
/**
* <p> Create a DOM tree.
* Has 'testsuites' as firstchild and aggregates all
* testsuite results that exists in the base directory.
* @return the root element of DOM tree that aggregates all testsuites.
*/
protected Element createDocument() {
// create the dom tree
DocumentBuilder builder = getDocumentBuilder();
Document doc = builder.newDocument();
Element rootElement = doc.createElement(TESTSUITES);
doc.appendChild(rootElement);
// get all files and add them to the document
File[] files = getFiles();
for (int i = 0; i < files.length; i++) {
try {
log("Parsing file: '" + files[i] + "'", Project.MSG_VERBOSE);
//XXX there seems to be a bug in xerces 1.3.0 that doesn't like file object
// will investigate later. It does not use the given directory but
// the vm dir instead ? Works fine with crimson.
Document testsuiteDoc
= builder.parse("file:///" + files[i].getAbsolutePath());
Element elem = testsuiteDoc.getDocumentElement();
// make sure that this is REALLY a testsuite.
if (TESTSUITE.equals(elem.getNodeName())) {
addTestSuite(rootElement, elem);
} else {
// issue a warning.
log("the file " + files[i] + " is not a valid testsuite XML document", Project.MSG_WARN);
}
} catch (SAXException e){
// a testcase might have failed and write a zero-length document,
// It has already failed, but hey.... mm. just put a warning
log("The file " + files[i] + " is not a valid XML document. It is possibly corrupted.", Project.MSG_WARN);
log(StringUtils.getStackTrace(e), Project.MSG_DEBUG);
} catch (IOException e){
log("Error while accessing file " + files[i] + ": " + e.getMessage(), Project.MSG_ERR);
}
}
return rootElement;
}
/**
* <p> Add a new testsuite node to the document.
* The main difference is that it
* split the previous fully qualified name into a package and a name.
* <p> For example: <tt>org.apache.Whatever</tt> will be split into
* <tt>org.apache</tt> and <tt>Whatever</tt>.
* @param root the root element to which the <tt>testsuite</tt> node should
* be appended.
* @param testsuite the element to append to the given root. It will slightly
* modify the original node to change the name attribute and add
* a package one.
*/
protected void addTestSuite(Element root, Element testsuite){
String fullclassname = testsuite.getAttribute(ATTR_NAME);
int pos = fullclassname.lastIndexOf('.');
// a missing . might imply no package at all. Don't get fooled.
String pkgName = (pos == -1) ? "" : fullclassname.substring(0, pos);
String classname = (pos == -1) ? fullclassname : fullclassname.substring(pos + 1);
Element copy = (Element) DOMUtil.importNode(root, testsuite);
// modify the name attribute and set the package
copy.setAttribute(ATTR_NAME, classname);
copy.setAttribute(ATTR_PACKAGE, pkgName);
}
/**
* Create a new document builder. Will issue an <tt>ExceptionInitializerError</tt>
* if something is going wrong. It is fatal anyway.
* @todo factorize this somewhere else. It is duplicated code.
* @return a new document builder to create a DOM
*/
private static DocumentBuilder getDocumentBuilder() {
try {
return DocumentBuilderFactory.newInstance().newDocumentBuilder();
} catch (Exception exc) {
throw new ExceptionInInitializerError(exc);
}
}
}