NIHVIVO-2811 Restructure the build utilities into a single directory, and compile them all at the beginning.

utilities/buildutils/src/edu/cornell/mannlib/vitro/utilities/anttasks/AbstractWrappedFileSet.java

@@ -0,0 +1,84 @@
+/* $This file is distributed under the terms of the license in /doc/license.txt$ */
+
+package edu.cornell.mannlib.vitro.utilities.anttasks;
+
+import java.io.File;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.types.FileSet;
+import org.apache.tools.ant.types.PatternSet;
+import org.apache.tools.ant.types.Resource;
+import org.apache.tools.ant.types.ResourceCollection;
+import org.apache.tools.ant.types.resources.FileResource;
+
+/**
+ * A base class for our custom-made FileSet extensions.
+ */
+public abstract class AbstractWrappedFileSet implements ResourceCollection {
+	private Project p;
+	
+	/** The list of FileResources that we will yield to the task. */
+	protected List<FileResource> files;
+	
+	/** The internal FileSet */
+	private FileSet fileSet = new FileSet();
+	
+	public void setProject(Project p) {
+		this.p = p;
+		fileSet.setProject(p);
+	}
+	
+	public void setDir(File dir) {
+		fileSet.setDir(dir);
+	}
+	
+    public PatternSet.NameEntry createInclude() {
+    	return fileSet.createInclude();
+    }
+
+    public PatternSet.NameEntry createExclude() {
+    	return fileSet.createExclude();
+    }
+    
+    public PatternSet createPatternSet() {
+    	return fileSet.createPatternSet();
+    }
+    	 
+    
+	@Override
+	public Object clone() {
+		throw new BuildException(this.getClass().getSimpleName()
+				+ " does not support cloning.");
+	}
+
+	@Override
+	public boolean isFilesystemOnly() {
+		return true;
+	}
+
+	@Override
+	public Iterator<? extends Resource> iterator() {
+		fillFileList();
+		return files.iterator();
+	}
+
+	@Override
+	public int size() {
+		fillFileList();
+		return files.size();
+	}
+
+	protected abstract void fillFileList();
+	
+	protected Project getProject() {
+		return p;
+	}
+	
+	protected FileSet getInternalFileSet() {
+		return fileSet;
+	}
+
+}

utilities/buildutils/src/edu/cornell/mannlib/vitro/utilities/anttasks/DirDifferenceFileSet.java

@@ -0,0 +1,59 @@
+/* $This file is distributed under the terms of the license in /doc/license.txt$ */
+
+package edu.cornell.mannlib.vitro.utilities.anttasks;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import org.apache.tools.ant.types.FileSet;
+import org.apache.tools.ant.types.Path;
+import org.apache.tools.ant.types.resources.FileResource;
+
+/**
+ * TODO
+ */
+public class DirDifferenceFileSet extends AbstractWrappedFileSet {
+	private Path blockingPath;
+
+    public Path createBlockingPath() {
+        if (blockingPath == null) {
+        	blockingPath = new Path(getProject());
+        }
+        return blockingPath.createPath();
+    }
+
+	@Override
+	protected void fillFileList() {
+		if (files != null) {
+			return;
+		}
+
+		FileSet fs = getInternalFileSet();
+
+		@SuppressWarnings("unchecked")
+		Iterator<FileResource> iter = fs.iterator();
+
+		files = new ArrayList<FileResource>();
+		while (iter.hasNext()) {
+			FileResource fr = iter.next();
+			if (!isBlocked(fr)) {
+				files.add(fr);
+			}
+		}
+	}
+
+	/**
+	 * Check to see whether this same file exists in any of the blocking
+	 * directories.
+	 */
+	private boolean isBlocked(FileResource fr) {
+		for (String blockingDir : blockingPath.list()) {
+			File f = new File(blockingDir + File.separator + fr.getName());
+			if (f.exists()) {
+				return true;
+			}
+		}
+		return false;
+	}
+}

utilities/buildutils/src/edu/cornell/mannlib/vitro/utilities/testing/VitroTestRunListener.java

@@ -0,0 +1,346 @@
+/* $This file is distributed under the terms of the license in /doc/license.txt$ */
+
+package edu.cornell.mannlib.vitro.utilities.testing;
+
+import static edu.cornell.mannlib.vitro.utilities.testing.VitroTestRunner.ReportLevel.BRIEF;
+import static edu.cornell.mannlib.vitro.utilities.testing.VitroTestRunner.ReportLevel.FULL;
+import static edu.cornell.mannlib.vitro.utilities.testing.VitroTestRunner.ReportLevel.MORE;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+import edu.cornell.mannlib.vitro.utilities.testing.VitroTestRunner.ReportLevel;
+
+/**
+ * Listen to events as they come from the JUnit test runner. The events from the
+ * lifecycle methods are broken down into semantic chunks and executed. Three
+ * levels of output are available.
+ * 
+ * On the surface, JUnit treats "failures" (failed assertions) the same as
+ * "errors" (unexpected exceptions). We're going to distinguish between them.
+ * 
+ * @author jeb228
+ */
+public class VitroTestRunListener extends RunListener {
+	private final ReportLevel reportLevel;
+
+	private int classCount;
+	private int testsTotal;
+	private int errorsTotal;
+	private int failuresTotal;
+	private int ignoresTotal;
+	private long overallStartTime;
+
+	private Class<?> currentClass;
+	private int testsCurrentClass;
+	private int errorsCurrentClass;
+	private int failuresCurrentClass;
+	private int ignoresCurrentClass;
+	private long classStartTime;
+
+	private String currentTest;
+	private boolean testHadError;
+	private boolean testFailed;
+	private boolean testIgnored;
+	private long testStartTime;
+
+	public VitroTestRunListener(ReportLevel reportLevel) {
+		this.reportLevel = reportLevel;
+	}
+
+	/** Did any of the tests fail or have errors? */
+	public boolean didEverythingPass() {
+		return (failuresTotal == 0) && (errorsTotal == 0);
+	}
+
+	// -------------------------------------------------------------------------
+	// Life-cycle methods that will be called by the test runner.
+	// -------------------------------------------------------------------------
+
+	@Override
+	public void testRunStarted(Description description) throws Exception {
+		openTestRun();
+		reportTestRunStart();
+	}
+
+	@Override
+	public void testStarted(Description description) throws Exception {
+		if (currentClass != description.getTestClass()) {
+			if (currentClass != null) {
+				closeCurrentClass();
+				reportCurrentClass();
+			}
+
+			openCurrentClass(description);
+			reportCurrentClassStart();
+		}
+
+		openCurrentTest(description);
+	}
+
+	@Override
+	public void testAssumptionFailure(Failure failure) {
+		if (isError(failure)) {
+			testHadError = true;
+			reportError(failure);
+		} else {
+			testFailed = true;
+			reportFailure(failure);
+		}
+	}
+
+	@Override
+	public void testFailure(Failure failure) throws Exception {
+		if (isError(failure)) {
+			testHadError = true;
+			reportError(failure);
+		} else {
+			testFailed = true;
+			reportFailure(failure);
+		}
+	}
+
+	@Override
+	public void testFinished(Description description) throws Exception {
+		closeCurrentTest();
+		reportCurrentTest();
+	}
+
+	@Override
+	public void testIgnored(Description description) throws Exception {
+		testStarted(description);
+		testIgnored = true;
+		testFinished(description);
+	}
+
+	@Override
+	public void testRunFinished(Result result) throws Exception {
+		if (currentClass != null) {
+			closeCurrentClass();
+			reportCurrentClass();
+		}
+		closeTestRun();
+		reportTestRun();
+		System.out.println();
+	}
+
+	// -------------------------------------------------------------------------
+	// Handling the logical events.
+	// -------------------------------------------------------------------------
+
+	private void openTestRun() {
+		overallStartTime = System.currentTimeMillis();
+	}
+
+	private void closeTestRun() {
+		// Nothing to close.
+	}
+
+	private void reportTestRunStart() {
+		if (reportLevel == FULL) {
+			System.out
+					.println("Starting test run at " + time(overallStartTime));
+			System.out.println();
+		}
+
+		if (reportLevel == MORE) {
+			System.out
+					.println("Starting test run at " + time(overallStartTime));
+			System.out.println();
+			System.out.println("Tests Pass Error Fail Ignore Seconds");
+		}
+	}
+
+	private void reportTestRun() {
+		int successes = testsTotal - errorsTotal - failuresTotal - ignoresTotal;
+
+		if (reportLevel != BRIEF) {
+			System.out.println();
+		}
+
+		System.out.format(
+				"Tests Pass Error Fail Ignore Seconds  TOTAL (%d classes)\n",
+				classCount);
+		System.out.format(" %4d %4d  %4d %4d  %4d  %6s\n", testsTotal,
+				successes, errorsTotal, failuresTotal, ignoresTotal,
+				elapsed(overallStartTime));
+
+		if (reportLevel != BRIEF) {
+			System.out.println("Ending test run at "
+					+ time(System.currentTimeMillis()));
+		}
+	}
+
+	private void openCurrentClass(Description description) {
+		currentClass = description.getTestClass();
+		classStartTime = System.currentTimeMillis();
+		testsCurrentClass = 0;
+		errorsCurrentClass = 0;
+		failuresCurrentClass = 0;
+		ignoresCurrentClass = 0;
+	}
+
+	private void closeCurrentClass() {
+		classCount++;
+		testsTotal += testsCurrentClass;
+		errorsTotal += errorsCurrentClass;
+		failuresTotal += failuresCurrentClass;
+		ignoresTotal += ignoresCurrentClass;
+	}
+
+	private void reportCurrentClassStart() {
+		if (reportLevel == FULL) {
+			System.out.format("Tests Pass Error Fail Ignore Seconds  %s\n",
+					currentClass.getName());
+		}
+	}
+
+	private void reportCurrentClass() {
+		int successes = testsCurrentClass - errorsCurrentClass
+				- failuresCurrentClass - ignoresCurrentClass;
+		if (reportLevel == MORE) {
+			System.out.format(" %4d %4d  %4d %4d  %4d  %6s %s\n",
+					testsCurrentClass, successes, errorsCurrentClass,
+					failuresCurrentClass, ignoresCurrentClass,
+					elapsed(classStartTime), currentClass.getSimpleName());
+		}
+		if (reportLevel == FULL) {
+			System.out.println("-----------------------------------");
+			System.out.format(" %4d %4d  %4d %4d  %4d  %6s\n",
+					testsCurrentClass, successes, errorsCurrentClass,
+					failuresCurrentClass, ignoresCurrentClass,
+					elapsed(classStartTime));
+			System.out.println();
+		}
+	}
+
+	private void openCurrentTest(Description description) {
+		currentTest = description.getMethodName();
+		testHadError = false;
+		testFailed = false;
+		testIgnored = false;
+		testStartTime = System.currentTimeMillis();
+	}
+
+	private void closeCurrentTest() {
+		if (testHadError) {
+			errorsCurrentClass++;
+		}
+		if (testFailed) {
+			failuresCurrentClass++;
+		}
+		if (testIgnored) {
+			ignoresCurrentClass++;
+		}
+		testsCurrentClass++;
+	}
+
+	private boolean isError(Failure failure) {
+		Throwable throwable = failure.getException();
+		return (throwable != null) && !(throwable instanceof AssertionError);
+	}
+
+	private void reportError(Failure error) {
+		Description description = error.getDescription();
+		String methodName = description.getMethodName();
+		String className = description.getTestClass().getName();
+		String message = error.getMessage();
+		System.out.format("EXCEPTION:   test %s() in %s: %s\n",
+				methodName, className, message);
+		System.out.println(formatStackTrace(error.getException()));
+	}
+
+	private void reportFailure(Failure failure) {
+		Description description = failure.getDescription();
+		String methodName = description.getMethodName();
+		String className = description.getTestClass().getName();
+		String message = failure.getMessage();
+		System.out.format("TEST FAILED: test %s() in %s: %s\n", methodName,
+				className, message);
+	}
+
+	private void reportCurrentTest() {
+		if (reportLevel == FULL) {
+			char passFlag = (testIgnored | testFailed | testHadError) ? ' '
+					: '1';
+			char errorFlag = testHadError ? '1' : ' ';
+			char failFlag = testFailed ? '1' : ' ';
+			char ignoreFlag = testIgnored ? '1' : ' ';
+			System.out.format(
+					"         %c     %c    %c      %c %6s        %s()\n",
+					passFlag, errorFlag, failFlag, ignoreFlag,
+					elapsed(testStartTime), currentTest);
+		}
+	}
+
+	// -------------------------------------------------------------------------
+	// Formatting methods.
+	// -------------------------------------------------------------------------
+
+	private final SimpleDateFormat formatter = new SimpleDateFormat(
+			"HH:mm:ss 'on' MMM dd, yyyy");
+
+	private String time(long time) {
+		return formatter.format(new Date(time));
+	}
+
+	/** Show elapsed time in 6 columns. */
+	private String elapsed(long start) {
+		long interval = System.currentTimeMillis() - start;
+		return String.format("%6.2f", ((float) interval) / 1000.0);
+	}
+
+	/**
+	 * Trim the stack trace: don't show the line saying "23 more", and don't
+	 * show the lines about org.junit or java.lang.reflect or sun.reflect.
+	 * 
+	 * Once we hit some "client code", we won't trim any futher lines even if
+	 * they belong to org.junit, or the others.
+	 * 
+	 * If we have nested exceptions, the process repeats for each "Caused by"
+	 * section.
+	 */
+	private String formatStackTrace(Throwable throwable) {
+		StringWriter w = new StringWriter();
+		throwable.printStackTrace(new PrintWriter(w));
+		String[] lineArray = w.toString().split("\\n");
+		List<String> lines = new ArrayList<String>(Arrays.asList(lineArray));
+
+		boolean removing = true;
+		for (int i = lines.size() - 1; i > 0; i--) {
+			String line = lines.get(i);
+			if (removing) {
+				if (line.matches("\\s*[\\.\\s\\d]+more\\s*")
+						|| line.contains("at "
+								+ VitroTestRunner.class.getName())
+						|| line.contains("at org.junit.")
+						|| line.contains("at java.lang.reflect.")
+						|| line.contains("at sun.reflect.")) {
+					lines.remove(line);
+				} else {
+					removing = false;
+				}
+			} else {
+				if (line.contains("Caused by: ")) {
+					removing = true;
+				}
+			}
+		}
+
+		StringBuilder result = new StringBuilder();
+		for (String line : lines) {
+			result.append(line).append('\n');
+		}
+		return result.toString().trim();
+	}
+}

utilities/buildutils/src/edu/cornell/mannlib/vitro/utilities/testing/VitroTestRunner.java

@@ -0,0 +1,153 @@
+/* $This file is distributed under the terms of the license in /doc/license.txt$ */
+
+package edu.cornell.mannlib.vitro.utilities.testing;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import org.junit.runner.JUnitCore;
+
+/**
+ * A Java application that will run the Vitro unit tests. It searches for unit
+ * tests in the supplied source directory (any file whose name is *Test.Java).
+ * It runs the tests with a variety of reporting detail, depending on the level
+ * selected. If the level selector is absent or unrecognized, the medium level
+ * is used.
+ * 
+ * @author jeb228
+ */
+public class VitroTestRunner {
+	public enum ReportLevel {
+		/** Report only the one-line summary. */
+		BRIEF,
+		/** Report times and statistics for each test class. */
+		MORE,
+		/** Report times and statistics for each test method. */
+		FULL
+	}
+
+	private final List<Class<?>> classes;
+	private final VitroTestRunListener listener;
+
+	/**
+	 * Locate the test classes. Initialize the test listener.
+	 */
+	public VitroTestRunner(File sourceRootDir, ReportLevel reportLevel) {
+		List<String> classNames = getListOfTestClassNames(sourceRootDir);
+		this.classes = getTestClasses(classNames);
+		this.listener = new VitroTestRunListener(reportLevel);
+	}
+
+	/**
+	 * Start a recursive search through the source directory.
+	 */
+	private List<String> getListOfTestClassNames(File sourceRootDir) {
+		SortedSet<String> names = new TreeSet<String>();
+		searchForTestClasses(names, "", sourceRootDir);
+		return new ArrayList<String>(names);
+	}
+
+	/**
+	 * Recursively search the directory for files in the form "*Test.java".
+	 * Ignore any files or directories whose names start with a "."
+	 */
+	private void searchForTestClasses(SortedSet<String> names, String prefix,
+			File directory) {
+		for (File file : directory.listFiles()) {
+			String filename = file.getName();
+			if (filename.startsWith(".")) {
+				// ignore .svn, etc.
+			} else if (file.isDirectory()) {
+				searchForTestClasses(names, prefix + filename + ".", file);
+			} else if (filename.endsWith("Test.java")) {
+				String classname = filename.substring(0, filename.length() - 5);
+				names.add(prefix + classname);
+			}
+		}
+	}
+
+	/**
+	 * Instantiate a class for each test class name.
+	 */
+	private List<Class<?>> getTestClasses(List<String> classNames) {
+		List<Class<?>> classes = new ArrayList<Class<?>>();
+		for (String classname : classNames) {
+			try {
+				classes.add(Class.forName(classname));
+			} catch (ClassNotFoundException e) {
+				throw new IllegalArgumentException("Can't load test class: "
+						+ classname, e);
+			}
+		}
+		return classes;
+	}
+
+	/**
+	 * We've located all of the test clases. Now run them.
+	 */
+	private void run() {
+		JUnitCore junitCore = new JUnitCore();
+		junitCore.addListener(this.listener);
+		junitCore.run(this.classes.toArray(new Class<?>[0]));
+	}
+
+	/**
+	 * Did any of the tests fail?
+	 */
+	private boolean didEverythingPass() {
+		return this.listener.didEverythingPass();
+	}
+
+	/**
+	 * <p>
+	 * You must provide a path to the source directory of the test classes.
+	 * </p>
+	 * <p>
+	 * You may also provide a reporting level of "BRIEF", "MORE", or "FULL". If
+	 * no level is provided, or if it is not recognized, "BRIEF" is used.
+	 * </p>
+	 */
+	public static void main(String[] args) {
+		if ((args.length < 1) || (args.length > 2)) {
+			usage("Wrong number of arguments: expecting 1 or 2, but found "
+					+ args.length + ".");
+		}
+		File sourceRootDir = new File(args[0]);
+
+		if (!sourceRootDir.exists()) {
+			usage(sourceRootDir + " does not exist.");
+		}
+		if (!sourceRootDir.isDirectory()) {
+			usage(sourceRootDir + " is not a directory.");
+		}
+
+		ReportLevel reportLevel = ReportLevel.MORE;
+		if (args.length == 2) {
+			for (ReportLevel level : ReportLevel.values()) {
+				if (level.toString().equalsIgnoreCase(args[1])) {
+					reportLevel = level;
+				}
+			}
+		}
+
+		VitroTestRunner runner = new VitroTestRunner(sourceRootDir, reportLevel);
+		runner.run();
+
+		if (!runner.didEverythingPass()) {
+			System.exit(1);
+		}
+	}
+
+	/**
+	 * Tell them how it should have been done.
+	 */
+	private static void usage(String message) {
+		System.out.println(message);
+		System.out.println("usage: " + VitroTestRunner.class.getSimpleName()
+				+ " sourceRootDirectory  [ BRIEF | MORE | FULL ]");
+		System.exit(1);
+	}
+}