1 files changed, 409 insertions, 0 deletions
diff --git a/aspectj-attic/testing-src/AntTaskTester.java b/aspectj-attic/testing-src/AntTaskTester.java
new file mode 100644
index 000000000..1f032e74f
--- /dev/null
+++ b/aspectj-attic/testing-src/AntTaskTester.java
@@ -0,0 +1,409 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+
+import org.apache.tools.ant.*;
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+
+/**
+ * Provides utility methods to test ant tasks.
+ */
+public abstract class AntTaskTester implements BuildListener {
+
+    public abstract String getAntFile();
+
+    protected PrintStream out = System.out;
+    protected PrintStream err = System.err;
+    protected void info(Object msg) {
+        out.println(" [" + msg + "]");
+    }
+
+    protected Project project;
+    protected String taskname = "unset";
+
+    protected List errors = new Vector();
+    protected void throwable(Throwable t) {
+        error(taskname, t);
+        t.printStackTrace();
+    }
+    protected void error(String task, Object msg) {
+        error("[" + task + "]: " + msg);
+    }
+    protected void error(Object msg) {
+        err.println("Error: " + msg);
+        errors.add(msg);
+    }
+
+    protected List wants = new Vector();
+    protected void want(Object object) {
+        wants.add(object);
+    }
+    protected List haves = new Vector();
+    protected void have(Object object) {
+        haves.add(object);
+    }
+    protected List donts = new Vector();
+    protected void dont(Object object) {
+        donts.add(object);
+    }
+
+    protected void clear() {
+        wants = new Vector();
+        haves = new Vector();
+        donts = new Vector();
+    }
+
+    protected final boolean verbose = verbose();
+    protected boolean verbose() { return false; }
+    protected void log(String msg) {
+        if (verbose) out.println("[ " + msg + " ]");
+    }
+
+    public void printSummary() {
+        Iterator iter = errors.iterator();
+        out.println();
+        out.println("----------------------- Test Summary -----------------------");
+        if (errors.size() == 0) {
+            out.println("no errors");
+        } else {
+            out.println(errors.size() + " error" + (errors.size() > 1 ? "s" : ""));
+            while (iter.hasNext()) {
+                out.println(" " + iter.next());
+            }
+        }
+        out.println("------------------------------------------------------------");
+    }
+
+    /**
+     * Checks the all the assertions we wanted were achieved
+     * and all those received were desired.
+     */
+    protected void checkAfterTask() {
+        log("checking after task");
+        for (Iterator i = wants.iterator(); i.hasNext();) {
+            Object want = i.next();
+            check(haves.contains(want),
+                  "didn't see " + want + " in " + haves);
+        }
+        for (Iterator i = haves.iterator(); i.hasNext();) {
+            Object have = i.next();
+            check(wants.contains(have),
+                  "shouldn't have seen " + have + " in " + wants);
+        }
+        for (Iterator i = donts.iterator(); i.hasNext();) {
+            Object dont = i.next();
+            check(!haves.contains(dont),
+                  "should't have seen " + dont + " in " + haves);
+        }
+    }
+
+    /**
+     * Logs an error in <code>!b</code> with message <code>msg</code>.
+     *
+     * @param b   <code>true</code> for an error.
+     * @param msg Failure message.
+     */
+    protected void check(boolean b, String msg) {
+        if (!b) error(taskname, msg);
+    }
+
+    /**
+     * Calls {@link #check(boolean,String)} with the result
+     * of comparing equality of <code>o1</code> and <code>o2</code>,
+     * failing with message <code>msg</code>.
+     *
+     * @param o1  First comparison.
+     * @param o2  Other comparison.
+     * @param msg Failure message.
+     */
+    protected void check(Object o1, Object o2, String msg) {
+        if (o1 != null) {
+            check(o1.equals(o2), msg);
+        } else if (o2 != null) {
+            check(o2.equals(o1), msg);
+        } else {
+            check(true, msg);
+        }
+    }
+
+    /**
+     * Calls {@link #runProject} with <code>args</code> and
+     * the result of {@link #getAntFile}.
+     *
+     * @param args Arguments given on the command line.
+     * @see   #runProject(String[], String)
+     */
+    public void runTests(String[] args) {
+        runProject(args, getAntFile());
+    }
+
+    /**
+     * Loads the project, collects a list of methods, and
+     * passes these methods to {@link #runProject(Method[])}.
+     *
+     * @param args      Command line arguments.
+     * @param buildFile XML file that we are giving to ANT.
+     * @see #runProject(Method[])
+     */
+    public void runProject(String[] args, String buildFile) {
+        loadProject(buildFile);
+        Method[] methods = null;
+        if (args == null || args.length == 0 || args[0].equals("${args}")) {
+            methods = getClass().getMethods();
+        } else {
+            methods = new Method[args.length];
+            for (int i = 0; i < args.length; i++) {
+                String name = args[i];
+                if (!Character.isJavaIdentifierStart(name.charAt(0)) || // todo wes: was (i)?
+                    name.charAt(0) == '$') {
+                    continue;
+                }
+                try {
+                    methods[i] = getClass().getMethod(name, new Class[]{});
+                } catch (NoSuchMethodException nsme) {
+                    methods[i] = null;
+                }
+            }
+        }
+        runProject(methods);
+    }
+
+    /**
+     * Execute the targets whose name matches those found in <code>methods</code>.
+     *
+     * @param methods List of methods to execute.
+     */
+    protected final void runProject(Method[] methods) {
+        if (methods == null || methods.length < 1) {
+            return;
+        }
+        for (int i = 0; i < methods.length; i++) {
+            Method method = methods[i];
+            if (method == null) {
+                error("a method is null!");
+                continue;
+            }
+            taskname = method.getName();
+            if (taskname.startsWith("test")) {
+                info("test task: " + taskname);
+                try {
+                    method.invoke(this, new Object[]{});
+                    beforeTasks();
+                    execute(taskname);
+                    afterTasks();
+                } catch (Throwable t) {
+                    throwable(t);
+                } finally {
+                    info("done task: " + taskname);
+                }
+            } else if (taskname.startsWith("fail")) {
+                info("fail task: " + taskname);
+                try {
+                    beforeTasks();
+                    want(taskname + "-error");
+                    execute(taskname);
+                    afterTasks();
+                } catch (Throwable t) {
+                    if (t instanceof BuildException) {
+                        have(taskname + "-error");
+                        try {
+                            method.invoke(this, new Object[]{t});
+                        } catch (Throwable tt) {
+                            throwable(tt);
+                        }
+                    } else {
+                        throwable(t);
+                    }
+                } finally {
+                    info("done task: " + taskname);
+                }
+            }
+        }
+        printSummary();
+    }
+
+    /**
+     * Called before every task.
+     */
+    private final void beforeTasks() {
+        clear();
+        beforeMethod();
+        beforeEveryTask();
+    }
+
+    /**
+     * Called after every task.
+     */
+    private final void afterTasks() {
+        afterMethod();
+        afterEveryTask();
+        checkAfterTask();
+    }    
+
+    /**
+     * Invokes the method with prefix <code>prefix</code>.
+     *
+     * @param prefix Prefix of the method to execute.
+     */
+    private final void taskMethod(String prefix) {
+        String name = prefix + Character.toUpperCase(taskname.charAt(0)) +
+            taskname.substring(1);
+        try {
+            Method method = getClass().getDeclaredMethod(name, new Class[]{});
+            if (method != null) {
+                method.invoke(this, new Object[]{});
+            }
+        } catch (Throwable t) {
+        }
+    }
+
+    /**
+     * Executes the method with prefix <code>after</code>.
+     */
+    private final void afterMethod() {
+        taskMethod("after");
+    }
+
+    /**
+     * Executes the method with prefix <code>before</code>.
+     */
+    private final void beforeMethod() {
+        taskMethod("before");
+    }
+
+    /**
+     * Override this to do some work before every task.
+     */
+    protected void beforeEveryTask() {}
+
+    /**
+     * Override this for initialization -- called at
+     * the end of {@link #loadProject}.
+     */
+    protected void init() {}
+
+    /**
+     * Override this to do some work after every task.
+     */
+    protected void afterEveryTask() {}
+
+    protected void setProperties(Map map, boolean user) {
+        Iterator iter = map.keySet().iterator();
+        while (iter.hasNext()) {
+            Object key = iter.next();
+            Object val = map.get(key);
+            String keyString = key + "";
+            String valString = val + "";
+            if (user) {
+                project.setUserProperty(keyString, valString);
+            } else {
+                project.setProperty(keyString, valString);
+            }
+        }
+    }
+
+    protected void setProperties() {
+        setProperties(getProperties(), false);
+    }
+
+    protected void setUserProperties() {
+        setProperties(getUserProperties(), true);
+    }
+
+    /**
+     * Override this to provide user properties -- default to
+     * an empty <code>HashMap</code>.
+     *
+     * @return Empty <code>HashMap</code>.
+     */
+    protected Map getUserProperties() {
+        return new HashMap();
+    }
+
+    /**
+     * Override this to provide system properties -- default to
+     * an empty <code>HashMap</code>.
+     *
+     * @return Empty <code>HashMap</code>.
+     */
+    protected Map getProperties() {
+        return new HashMap();
+    }
+
+    /**
+     * Loads the project with file name <code>buildFile</code>.
+     *
+     * @param buildFile Name of the XML file to load.
+     */
+    public void loadProject(String buildFile) {
+        project = new Project();
+        project.init();
+        project.setUserProperty("ant.file", new File(buildFile).getAbsolutePath() );
+        setProperties();
+        setUserProperties();
+        project.addBuildListener(this);
+        ProjectHelper.configureProject(project, new File(buildFile));
+        init();
+    }
+
+    public void execute(String targetName) {
+        try { 
+            project.executeTarget(targetName);
+        } finally { 
+        }
+    }
+
+    private static class StringBufferOutputStream extends OutputStream {
+        private StringBuffer buf;
+        public StringBufferOutputStream(StringBuffer buf) {
+            this.buf = buf;
+        }
+        public void write(int c) { 
+            buf.append((char)c);
+        }
+    }
+
+    public boolean verbosity(BuildEvent event) {
+        int[] verbosities = verbosities();
+        int priority = event.getPriority();
+        for (int i = 0; i < verbosities.length; i++) {
+            if (priority == verbosities[i]) return true;
+        }
+        return false;
+    }
+
+    public int[] verbosities() {
+        return new int[] { /*Project.MSG_VERBOSE,*/ Project.MSG_INFO, Project.MSG_WARN, project.MSG_ERR };
+    }
+
+    // BuildListener
+    public void buildFinished(BuildEvent event) {
+    }
+    public void buildStarted(BuildEvent event) {
+    }
+    public void messageLogged(BuildEvent event) {
+        if (verbosity(event)) {
+            out.println(event.getMessage());
+        }
+    }
+    public void targetFinished(BuildEvent event) {
+    }
+    public void targetStarted(BuildEvent event) {
+    }
+    public void taskFinished(BuildEvent event) {
+    }
+    public void taskStarted(BuildEvent event) {
+    }
+}