View Javadoc
   package junit.quilt.ant;
   
   import java.net.URL;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.OutputStream;
   import java.io.FileOutputStream;
   
  import java.util.List;
  import java.util.Iterator;
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.StringTokenizer;
  
  import org.apache.tools.ant.*;
  import org.apache.tools.ant.types.*;
  
  import junit.framework.*;
  
  import junit.quilt.framework.*;
  import junit.quilt.reports.*;
  import junit.quilt.runner.*;
  
  public class AntQuiltRunner
      extends Task
  {
      private List filesets = new ArrayList();
  
      private Report reporter = null;
      private Class registryClass = null;
      private AntClassLoader antLoader = null;
      private File reportDir = null;
      private List packages = new ArrayList();
      private Path compileClasspath = null;
      private String ext = "rpt";
  
      private class AQR
  	extends QuiltRunner
      {
  	public AQR( Class registryClass,
  		    ClassLoader parent,
  		    List urls,
  		    List packages )
  	    throws Exception
  	{
  	    super( registryClass, parent, urls, packages );
  	}
  
  	public void startTest( Test test ) { }
  	public void endTest( Test test ) { }
  	public void runFailed( String reason ) { }
  	public void addFailure( Test test, AssertionFailedError error ) 
  	{ 
  	    System.out.println("Failure: " + test.toString());
  	    System.out.println("\t: " + error.toString());
  	}
  	
  	public void addError( Test test, Throwable error ) 
  	{ 
  	    System.out.println();
  	    System.out.println("Error: " + test.toString());
  	    System.out.println("\t: " + error.toString());
  	}	
      }
  
      public AntQuiltRunner() {
      }
  
      public void setReportdir( File reportDir ) {
  	this.reportDir = reportDir;
      }
  
      public void setPackages( String packs ) {
  	StringTokenizer tokens = new StringTokenizer(packs, ";");
  	while (tokens.hasMoreElements()) {
  	    packages.add( tokens.nextToken() );
  	}
      }
  
      public void setRegister( String register ) 
  	throws BuildException
      {
  	try {
  	    this.registryClass =
  		getClass().getClassLoader().loadClass( register );
  	} catch (Exception e) {
  	    throw new BuildException( e.toString() );
  	}
      }
  
      public void setReporter( String reporter )
  	throws BuildException
      {
  	try {
  	    ClassLoader mine = getClass().getClassLoader();
  
  	    Class reporterClass = mine.loadClass( reporter );
  	    this.reporter = (Report) reporterClass.newInstance();
 	} catch (Exception ex) {
 	    throw new BuildException( reporter.toString() + 
 				      " is not a valid Reporter.");
 	}
     }
 
 
 //      public void setIgnoredpkg( String ignoredPkg ) {
 //  	StringTokenizer tokenizer = new StringTokenizer( ignoredPkg, "," );
 //  	while (tokenizer.hasMoreElements()) {
 //  	    String pack = tokenizer.nextToken();
 //  	    ignoredPkgs.add( pack + "." );
 //  	}
 //      }
 
     public void setClasspath( Path classPath ) {
 	this.compileClasspath = classPath;
     }
 
     public void setClasspathRef( Reference ref ) {
 	createClasspath().setRefid( ref );
     }
 
     public Path createClasspath() {
 	if (compileClasspath == null) {
 	    compileClasspath = new Path( project );
 	}
 	return compileClasspath;
     }
 
     public Path getClasspath() {
 	return compileClasspath;
     }
 
     public void addFileset( FileSet fileset ) {
 	filesets.add( fileset );
     }
 
     /***
      * makeTestName
      *
      * Test names come in looking like /a/b/c/d.class
      * or /a/b/c/d.java
      *
      * Change them into a.b.c.d
      */
     public String makeTestName( String rawTestName ) {
 	String RC = rawTestName;
 	if (RC.startsWith("/")) 
 	    RC = RC.substring( 1 );
 	
 	if ((RC.endsWith(".class")) ||
 	    (RC.endsWith(".java")))
 	    RC = RC.substring( 0, RC.lastIndexOf('.'));
 	
 	RC = RC.replace('/','.');
 	
 	return RC;
     }
 
 
     /***
      * getReportOutput
      *
      * Return an output stream for writing the coverage
      * results.
      */
     public OutputStream getReportOutput( String testName ) 
 	throws IOException
     {
 	File outFile = new File( reportDir, "COVER-" + testName + "." + ext);
 	return new FileOutputStream( outFile );
     }
     
 
     public void execute() {
 	try {
 	    Path cp = null;
 	    if (getClasspath() != null) {
 		cp = getClasspath();
 	    } else {
 		cp = Path.systemClasspath;
 	    }
 
 	    List urls = new ArrayList();
 	    String paths[] = cp.list();
 	    for (int i = 0; i < paths.length; i++) {
 		URL url = new File( paths[i] ).toURL();
 		urls.add( url );
 	    }
 
 	    Iterator i = filesets.iterator();
 	    while (i.hasNext()) {
 		QuiltRunner runner = new AQR( registryClass, 
 					      getClass().getClassLoader(),
 					      urls,
 					      packages );
 		
 		FileSet fileset = (FileSet) i.next();
 		FileScanner scanner = fileset.getDirectoryScanner( getProject() );
 		
 		String files[] = scanner.getIncludedFiles();
 		
 		for (int j = 0; j < files.length; j++) {
 		    TestResult result = 
 			runner.executeTest(makeTestName( files[j] ));
 		    if (result.wasSuccessful()) {
 			try {
 			    reporter.writeReport( getReportOutput( makeTestName( files[j] )),
 						  runner.getRegistry() );
 			} catch (IOException e) {
 			    throw new BuildException("Failed to write report: " + 
 						     e.toString() );
 			}
 		    } else {
 			System.err.println("There were failures." +
 					   "Use JUnit to get " +
 					   "more information.");
 			System.err.println("If JUnit did not report these errors, ");
 			System.err.println("please report problem to ");
 			System.err.println("http://sourceforge.net/projects/quilt");
 			System.err.println();
 			
 			if (result.errorCount() != 0) {
 			    System.err.println("# ERRORS: " + result.errorCount());
 			    Enumeration errs = result.errors();
 			    while (errs.hasMoreElements()) {
 				TestFailure t = (TestFailure) errs.nextElement();
 				System.err.println(t.failedTest() );
 				t.thrownException().printStackTrace();
 			    }
 			}
 			
 			if (result.failureCount() != 0) {
 			    System.err.println("# FAILURES: " + result.failureCount() );
 			}
 		    }
 		}
 	    }
 	} catch (Exception ex) {
 	    throw new BuildException( ex );
 	}
     }
     
 }