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
  {
      // Will try to implement fork="yes"
      private boolean fork = false;
      private List filesets = new ArrayList();
      private Report reporter = null;
      private Class registryClass = null;
      private File report = null;
      private List packages = new ArrayList();
      private Path compileClasspath = null;
  
      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() {
      }
  
      /***
       * Determines whether to start a new JVM or not.
       */
      public void setFork( boolean value ) {
  	fork = true;
      }
  
      /***
       * Sets the output directory for reports.
       */
      public void setReport( File report ) {
  	this.report = report;
      }
  
      /***
       * This is a semicolon list of packages to be
       * instrumented.
       */
      public void setPackages( String packs ) {
  	StringTokenizer tokens = new StringTokenizer(packs, ";");
  	while (tokens.hasMoreElements()) {
  	    packages.add( tokens.nextToken() );
  	}
      }
  
      /***
       * This will set the Coverage technique.
       * Current registers are:
       *    junit.quilt.cover.state.StateMachineRegister
       *    junit.quilt.cover.ball94.B94Register
       */
     public void setRegister( String register ) 
 	throws BuildException
     {
 	try {
 	    this.registryClass =
 		getClass().getClassLoader().loadClass( register );
 	} catch (Exception e) {
 	    throw new BuildException( e.toString() );
 	}
     }
 
     /***
      * This determines which type of reports will
      * be generated.
      * Current values are:
      *   junit.quilt.reports.XMLSummary
      *   junit.quilt.reports.TreeSummary
      */
     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.");
 	}
     }
 
     /***
      * This sets the full ClassPath for running the
      * tests.  Instrumented code is determined by
      * the packages parameter.
      */
     public void setClasspath( Path classPath ) {
 	this.compileClasspath = classPath;
     }
 
     /***
      * This sets a classpath reference it can use.
      */
     public void setClasspathRef( Reference ref ) {
 	createClasspath().setRefid( ref );
     }
 
     /***
      * This allows for the classpath to be embedded
      * between the tags.
      */
     public Path createClasspath() {
 	if (compileClasspath == null) {
 	    compileClasspath = new Path( project );
 	}
 	return compileClasspath;
     }
 
     /***
      * This fileset is the tests to be run.
      */
     public void addFileset( FileSet fileset ) {
 	filesets.add( fileset );
     }
 
     /***
      * Useful method for getting the ClassPath.
      */
     public Path getClasspath() {
 	return compileClasspath;
     }
 
     /***
      * Adds a System Property.
      */
     public void addSyproperty( Environment.Variable sysp ) {
 	// TODO:  Do something here. . .
     }
 
     /***
      * 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(File.separator)) 
 	    RC = RC.substring( 1 );
 	
 	if ((RC.endsWith(".class")) ||
 	    (RC.endsWith(".java")))
 	    RC = RC.substring( 0, RC.lastIndexOf('.'));
 	
 	RC = RC.replace(File.separatorChar,'.');
 	return RC;
     }
 
 
     /***
      * Ant calls this to start our coverage analasys.
      */
     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 );
 	    }
 
 	    QuiltRunner runner = new AQR( registryClass, 
 					  getClass().getClassLoader(),
 					  urls,
 					  packages );
 
 	    Iterator i = filesets.iterator();
 	    while (i.hasNext()) {
 		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()) {
 			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() );
 			}
 		    }
 
 		    try {
 			reporter.writeReport( new FileOutputStream( report ), 
 					      runner.getRegistry() );
 		    } catch (IOException e) {
 			throw new BuildException("Failed to write report: " + 
 						 e.toString() );
 		    }
 		}
 	    }
 	} catch (Exception ex) {
 	    throw new BuildException( ex );
 	}
     }
     
 }