tidyup retired modules and add aspectjtools submodule

23 files changed, 0 insertions, 5062 deletions

diff --git a/aspectj-attic/testing-src/AjcTaskTester.java b/aspectj-attic/testing-src/AjcTaskTester.java
deleted file mode 100644
index 0f9e728ba..000000000
--- a/aspectj-attic/testing-src/AjcTaskTester.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/* *******************************************************************
- * 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 java.io.*;
-import java.util.*;
-import org.apache.tools.ant.*;
-import org.apache.tools.ant.taskdefs.*;
-import org.apache.tools.ant.types.*;
-
-/**
- * Tests the AJC ant task.
- */
-public class AjcTaskTester extends AntTaskTester {
-
-    protected final static String TEST_CLASSES = "test-classes";
-    protected final static String TEST_SOURCES = "../src";
-    protected File buildDir = null;
-
-    /**
-     * We use <code>"tests/ant/etc/ajc.xml"</code>.
-     */
-    public String getAntFile() {
-        return "tests/ant/etc/ajc.xml";
-    }
-
-    /**
-     * Put {@link #TEST_CLASSES} and {@link #TEST_SOURCES}
-     * into the user properties.
-     */
-    protected Map getUserProperties() {
-        Map userProps = new HashMap();
-        userProps.put("ant.test.classes", TEST_CLASSES);
-        userProps.put("ant.test.sources", TEST_SOURCES);        
-        return userProps;
-    }
-
-    ////// Begin tests //////////////////////////////////////////////
-
-    public void test1() { wantClasses("One"); }
-    public void test2() { wantClasses("One,Two"); }
-    public void test3() { wantClasses("One,Two,Three"); }
-    public void test4() { wantClasses("One"); }
-    public void test4b() { wantClasses("One"); }
-    public void test5() { wantClasses("One,Two"); }
-    public void test5b() { wantClasses("One,Two"); }
-    public void test6() { wantClasses("One,Two,Three"); }
-    public void test6b() { wantClasses("One,Two,Three"); }
-    public void test8() { wantClasses("One"); }
-    public void test9() { wantClasses("One"); }
-    public void test10() { wantClasses("One"); }
-    public void test11() { wantClasses("One"); }
-    public void test12() { wantClasses(""); }
-    public void test13() { wantClasses("One"); }
-    public void fail1(BuildException be) {}
-    public void fail2(BuildException be) {}
-    public void fail3(BuildException be) {}
-
-    public void test1_fork() { wantClasses("One"); }
-    public void test2_fork() { wantClasses("One,Two"); }
-    public void test3_fork() { wantClasses("One,Two,Three"); }
-    public void test4_fork() { wantClasses("One"); }
-    public void test4b_fork() { wantClasses("One"); }
-    public void test5_fork() { wantClasses("One,Two"); }
-    public void test5b_fork() { wantClasses("One,Two"); }
-    public void test6_fork() { wantClasses("One,Two,Three"); }
-    public void test6b_fork() { wantClasses("One,Two,Three"); }
-    public void test8_fork() { wantClasses("One"); }
-    public void test9_fork() { wantClasses("One"); }
-    public void test10_fork() { wantClasses("One"); }
-    public void test11_fork() { wantClasses("One"); }
-    public void test12_fork() { wantClasses(""); }
-    public void test13_fork() { wantClasses("One"); }
-    public void fail1_fork(BuildException be) {}
-    public void fail2_fork(BuildException be) {}
-    public void fail3_fork(BuildException be) {}  
-
-    ////// End tests ////////////////////////////////////////////////
-
-    /**
-     * Make the build dir -- e.g. call {@link #makeBuildDir}
-     */
-    protected void beforeEveryTask() {
-        makeBuildDir();
-    }
-
-    /**
-     * Assert classes and clear build dir.
-     *
-     * @see #checkClasses()
-     * @see #clearBuildDir()
-     */
-    protected void afterEveryTask() {
-        checkClasses();
-        clearBuildDir();
-    }
-
-    /**
-     * Expect the classes found in
-     * <code>classNamesWithoutExtensions</code>
-     *
-     * @param classNamesWithoutExtensions Array of class names without
-     *                                    extensions we want to see.
-     * @see   #wantClasses(List)
-     */
-    protected void wantClasses(String[] classNamesWithoutExtensions) {
-        List list = new Vector();
-        for (int i = 0; i < classNamesWithoutExtensions.length; i++) {
-            list.add(classNamesWithoutExtensions[i]);
-        }
-        wantClasses(list);
-    }
-    
-    /**
-     * Expect the classes found in
-     * <code>classNamesWithoutExtensions</code>
-     *
-     * @param classNamesWithoutExtensions String of class names without
-     *                                    extensions we want to see separated
-     *                                    by <code> </code>, <code>,</code>, or
-     *                                    <code>;</code>.
-     * @see   #wantClasses(List)
-     */
-    protected void wantClasses(String classNamesWithoutExtensions) {
-        StringTokenizer tok = new StringTokenizer(classNamesWithoutExtensions, " ,;");
-        List list = new Vector();
-        while (tok.hasMoreTokens()) {
-            list.add(tok.nextToken());
-        }
-        wantClasses(list);
-    }
-
-    /**
-     * Expected each class name found in
-     * <code>classNamesWithoutExtensions</code>.
-     *
-     * @param classNamesWithoutExtensions List of class names without
-     *                                    exntensions.
-     * @see   #want(Object)
-     */
-    protected void wantClasses(List classNamesWithoutExtensions) {
-        Iterator iter = classNamesWithoutExtensions.iterator();
-        while (iter.hasNext()) {
-            String className = iter.next() + "";
-            className = className.replace('.', '/').replace('\\', '/');
-            want(className + ".class");
-        }
-    }
-
-    /**
-     * Assert that all classes in {@link #wants} were found.
-     */
-    protected void checkClasses() {
-        Iterator iter = wants.iterator();
-        while (iter.hasNext()) {
-            String className = iter.next() + "";
-            File file = new File(buildDir, className);
-            if (file != null && file.exists()) {
-                have(className);
-            }
-        }
-    }
-
-    /**
-     * Create a new build dir.
-     */
-    protected void init() {
-        buildDir = new File(project.getBaseDir(), TEST_CLASSES);
-    }
-
-    /**
-     * Make a new build dir using ANT.
-     */
-    protected void makeBuildDir() {
-        try {
-            Mkdir mkdir = (Mkdir)project.createTask("mkdir");
-            mkdir.setDir(buildDir);
-            mkdir.execute();
-        } catch (BuildException be) {
-            be.printStackTrace();
-        }
-    }
-
-    /**
-     * Clear the build dir using ANT.
-     */
-    protected void clearBuildDir() {
-        try {
-            Delete delete = (Delete)project.createTask("delete");
-            FileSet fileset = new FileSet();
-            fileset.setDir(buildDir);
-            fileset.setIncludes("**");
-            delete.addFileset(fileset);
-            delete.execute();
-        } catch (BuildException be) {
-            be.printStackTrace();
-        }        
-    }
-
-    /**
-     * Invoke {@link #runTests(String[])} on a
-     * new instanceof {@link #AjcTaskTester}.
-     *
-     * @param args Command line arguments.
-     */
-    public static void main(String[] args) {
-        new AjcTaskTester().runTests(args);
-    }
-}
diff --git a/aspectj-attic/testing-src/AjcTaskTester2.java b/aspectj-attic/testing-src/AjcTaskTester2.java
deleted file mode 100644
index f5c5b36db..000000000
--- a/aspectj-attic/testing-src/AjcTaskTester2.java
+++ /dev/null
@@ -1,202 +0,0 @@
-/* *******************************************************************
- * 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 java.io.*;
-import java.util.*;
-import org.apache.tools.ant.*;
-import org.apache.tools.ant.taskdefs.*;
-import org.apache.tools.ant.types.*;
-
-
-/**
- * Tests the AJC2 ant task.
- */
-public class AjcTaskTester2 extends AntTaskTester {
-
-    protected final static String TEST_CLASSES = "test-classes";
-    protected final static String TEST_SOURCES = "../src";
-    protected File buildDir = null;
-
-    /**
-     * We use <code>"tests/ant/etc/ajc2.xml"</code>.
-     */
-    public String getAntFile() {
-        return "tests/ant/etc/ajc2.xml";
-    }
-
-    /**
-     * Put {@link #TEST_CLASSES} and {@link #TEST_SOURCES}
-     * into the user properties.
-     */
-    protected Map getUserProperties() {
-        Map userProps = new HashMap();
-        userProps.put("ant.test.classes", TEST_CLASSES);
-        userProps.put("ant.test.sources", TEST_SOURCES);        
-        return userProps;
-    }
-
-    ////// Begin tests //////////////////////////////////////////////
-
-    public void test1()   { wantClasses("One"); }
-    public void test2()   { wantClasses("One,Two"); }
-    public void test3()   { wantClasses("One,Two,Three"); }
-    public void test4()   { wantClasses("One"); }
-    public void test4b()  { wantClasses("One"); }
-    public void test5()   { wantClasses("One,Two"); }
-    public void test5b()  { wantClasses("One,Two"); }
-    public void test6()   { wantClasses("One,Two,Three"); }
-    public void test6b()  { wantClasses("One,Two,Three"); }
-    public void test8()   { wantClasses("One"); }
-    public void test9()   { wantClasses("One"); }
-    public void test10()  { wantClasses("One"); }
-    public void test11()  { wantClasses("One"); }
-    public void test12()  { wantClasses(""); }
-    public void test13()  { wantClasses("One"); }
-    public void fail1(BuildException be) {}
-    public void fail2(BuildException be) {}
-    public void fail3(BuildException be) {}   
-
-    ////// End tests ////////////////////////////////////////////////
-
-    /**
-     * Make the build dir -- e.g. call {@link #makeBuildDir}
-     */
-    protected void beforeEveryTask() {
-        makeBuildDir();
-    }
-
-    /**
-     * Assert classes and clear build dir.
-     *
-     * @see #checkClasses()
-     * @see #clearBuildDir()
-     */
-    protected void afterEveryTask() {
-        checkClasses();
-        clearBuildDir();
-    }
-
-
-    /**
-     * Expect the classes found in
-     * <code>classNamesWithoutExtensions</code>
-     *
-     * @param classNamesWithoutExtensions Array of class names without
-     *                                    extensions we want to see.
-     * @see   #wantClasses(List)
-     */
-    protected void wantClasses(String[] classNamesWithoutExtensions) {
-        List list = new Vector();
-        for (int i = 0; i < classNamesWithoutExtensions.length; i++) {
-            list.add(classNamesWithoutExtensions[i]);
-        }
-        wantClasses(list);
-    }
-    
-    /**
-     * Expect the classes found in
-     * <code>classNamesWithoutExtensions</code>
-     *
-     * @param classNamesWithoutExtensions String of class names without
-     *                                    extensions we want to see separated
-     *                                    by <code> </code>, <code>,</code>, or
-     *                                    <code>;</code>.
-     * @see   #wantClasses(List)
-     */
-    protected void wantClasses(String classNamesWithoutExtensions) {
-        StringTokenizer tok = new StringTokenizer(classNamesWithoutExtensions, ",;");
-        List list = new Vector();
-        while (tok.hasMoreTokens()) {
-            list.add(tok.nextToken());
-        }
-        wantClasses(list);
-    }
-
-    /**
-     * Expected each class name found in
-     * <code>classNamesWithoutExtensions</code>.
-     *
-     * @param classNamesWithoutExtensions List of class names without
-     *                                    exntensions.
-     * @see   #want(Object)
-     */
-    protected void wantClasses(List classNamesWithoutExtensions) {
-        Iterator iter = classNamesWithoutExtensions.iterator();
-        while (iter.hasNext()) {
-            String className = iter.next() + "";
-            className = className.replace('.', '/').replace('\\', '/');
-            want(className + ".class");
-        }
-    }
-
-    /**
-     * Assert that all classes in {@link #wants} were found.
-     */
-    protected void checkClasses() {
-        Iterator iter = wants.iterator();
-        while (iter.hasNext()) {
-            String className = iter.next() + "";
-            File file = new File(buildDir, className);
-            if (file != null && file.exists()) {
-                have(className);
-            }
-        }
-    }
-
-    /**
-     * Create a new build dir.
-     */
-    protected void init() {
-        buildDir = new File(project.getBaseDir(), TEST_CLASSES);
-    }
-
-    /**
-     * Make a new build dir using ANT.
-     */
-    protected void makeBuildDir() {
-        try {
-            Mkdir mkdir = (Mkdir)project.createTask("mkdir");
-            mkdir.setDir(buildDir);
-            mkdir.execute();
-        } catch (BuildException be) {
-            be.printStackTrace();
-        }
-    }
-
-    /**
-     * Clear the build dir using ANT.
-     */
-    protected void clearBuildDir() {
-        try {
-            Delete delete = (Delete)project.createTask("delete");
-            FileSet fileset = new FileSet();
-            fileset.setDir(buildDir);
-            fileset.setIncludes("**");
-            delete.addFileset(fileset);
-            delete.execute();
-        } catch (BuildException be) {
-            be.printStackTrace();
-        }        
-    }
-
-    /**
-     * Invoke {@link #runTests(String[])} on a
-     * new instanceof {@link #AjcTaskTester2}.
-     *
-     * @param args Command line arguments.
-     */
-    public static void main(String[] args) {
-        new AjcTaskTester2().runTests(args);
-    }
-}
diff --git a/aspectj-attic/testing-src/AjdocTaskTester.java b/aspectj-attic/testing-src/AjdocTaskTester.java
deleted file mode 100644
index a0e397013..000000000
--- a/aspectj-attic/testing-src/AjdocTaskTester.java
+++ /dev/null
@@ -1,366 +0,0 @@
-/* *******************************************************************
- * 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 java.io.*;
-import java.util.*;
-import org.apache.tools.ant.*;
-import org.apache.tools.ant.taskdefs.*;
-import org.apache.tools.ant.types.*;
-
-/**
- * Tests the Ajdoc ant task.
- */
-public class AjdocTaskTester extends AntTaskTester {
-
-    /** todo correlate with basedir, local.properties in test-ant-task */
-    protected final static String TEST_DOCDIR  
-        = "test-docs";
-    protected final static String TEST_SOURCES = "../src";
-    protected File docDir = null;
-
-    /**
-     * We use <code>"tests/ant/etc/ajc.xml"</code>.
-     */
-    public String getAntFile() {
-        return "tests/ant/etc/ajdoc.xml";
-    }
-
-    /**
-     * Put {@link #TEST_DOCDIR} and {@link #TEST_SOURCES}
-     * into the user properties.
-     */
-    protected Map getUserProperties() {
-        Map userProps = new HashMap();
-        // these are in local.properties per test-ant-tasks.xml
-        //userProps.put("ajdoc.relative.doc.dir", TEST_DOCDIR );
-        //userProps.put("ajdoc.relative.src.dir", TEST_SOURCES);        
-        return userProps;
-    }
-
-    ////// Begin tests //////////////////////////////////////////////
-
-    public void test_stylesheetfile() {
-        avoid(STYLESHEET_CSS);
-        wantFiles("One.html");
-        wantFiles("mystylesheet.css");
-    }
-
-    public void test_helpfile() {
-        avoid(HELP_DOC_HTML);
-        wantFiles("One.html");
-        wantFiles("myhelp.html");
-    }
-
-    public void test_nodeprecatedlist_no() {
-        wantFiles("One.html");
-    }
-    public void test_nodeprecatedlist_yes() {
-        avoid(DEPRECATED_LIST_HTML);
-        wantFiles("One.html");
-    }
-
-    public void test_nodeprecated_no() { wantFiles("One.html"); }
-    public void test_nodeprecated_yes() { wantFiles("One.html"); }
-
-    public void test_use_no() {
-        wantFiles("One.html");
-    }
-    public void test_use_yes() {
-        wantFiles("One.html");
-        wantFiles("class-use/One.html");
-    }
-
-    public void test_standard_no() {
-        wantFiles("One.html");
-    }
-    public void test_standard_yes() {
-        wantFiles("One.html");
-    }
-
-    public void test_author_no() { wantFiles("One.html"); }
-    public void test_author_yes() { wantFiles("One.html"); }
-
-    public void test_public_no() { wantFiles("One.html"); }
-    public void test_public_yes() { wantFiles("One.html"); }
-    public void test_package_no() { wantFiles("One.html"); }
-    public void test_package_yes() { wantFiles("One.html"); }
-    public void test_protected_no() { wantFiles("One.html"); }
-    public void test_protected_yes() { wantFiles("One.html"); }
-    public void test_private_no() { wantFiles("One.html"); }
-    public void test_private_yes() { wantFiles("One.html"); }
-
-    public void test_splitindex_no() {
-        wantFiles("One.html");
-    }
-    public void test_splitindex_yes() {
-        avoid(INDEX_ALL_HTML);
-        wantFiles("One.html");
-    }
-    
-    public void test_windowtitle() {
-        wantFiles("One.html");
-    }
-    public void test_doctitle() {
-        wantFiles("One.html");
-    }
-    public void test_bottom() {
-        wantFiles("One.html");
-    }
-    public void test_footer() {
-        wantFiles("One.html");
-    }
-    public void test_header() {
-        wantFiles("One.html");
-    }
-
-    public void test_nohelp_no() {
-        wantFiles("One.html");
-    }
-    public void test_nohelp_yes() {
-        avoid(HELP_DOC_HTML);
-        wantFiles("One.html");
-    }
-
-    public void test_noindex_no() {
-        wantFiles("One.html");
-    }
-    public void test_noindex_yes() {
-        avoid(INDEX_ALL_HTML);
-        wantFiles("One.html");
-    }
-
-    public void test_notree_no() {
-        wantFiles("One.html");
-    }
-    public void test_notree_yes() {
-        avoid(OVERVIEW_TREE_HTML);
-        wantFiles("One.html");
-    }
-
-    public void test985() {
-        wantFiles("p1/One.html,p1/pp1/One.html");
-        wantFiles("p2/Two.html,p2/pp2/Two.html");
-    }
-    public void test986() {
-        wantFiles("p1/One.html,p1/pp1/One.html");
-    }
-    public void test987() {
-        wantFiles("p1/One.html");
-        wantFiles("p2/Two.html");
-    }
-    public void test988() {
-        wantFiles("p1/One.html");
-    }
-    public void test989() {
-        wantFiles("p1/One.html,p1/pp1/One.html");
-        wantFiles("p2/Two.html,p2/pp2/Two.html");
-    }
-    public void test990() {
-        wantFiles("p1/One.html,p1/pp1/One.html");
-        wantFiles("p2/Two.html,p2/pp2/Two.html");
-    }
-    public void test991() {
-        wantFiles("p1/One.html,p1/pp1/One.html");
-        wantFiles("p2/Two.html");
-    }
-    public void test992() {
-        wantFiles("p1/One.html,p2/Two.html");
-    }
-    public void test993() {
-        wantFiles("p1/One.html,p1/pp1/One.html");
-    }
-    public void test994() {
-        wantFiles("p1/One.html,p1/pp1/One.html");
-    }
-    public void test995() {
-        wantFiles("p1/One.html");
-    }
-    public void test996() {
-        wantFiles("One.html,Two.html");
-    }
-    public void test997() {
-        wantFiles("One.html");
-    }
-    public void test998() {
-        wantFiles("One.html,Two.html");
-    }
-    public void test999() {
-        wantFiles("One.html");
-    }
-
-
-
-    ////// End tests ////////////////////////////////////////////////
-
-    private final static int OVERVIEW_TREE_HTML           = 0x000001;
-    private final static int INDEX_ALL_HTML               = 0x000002;
-    private final static int DEPRECATED_LIST_HTML         = 0x000004;
-    private final static int ALLCLASSES_FRAME_HTML        = 0x000008;
-    private final static int INDEX_HTML                   = 0x000010;
-    private final static int PACKAGES_HTML                = 0x000020;
-    private final static int OVERVIEW_SUMMARY_HTML        = 0x000040;
-    private final static int PACKAGE_LIST                 = 0x000080;
-    private final static int HELP_DOC_HTML                = 0x000100;
-    private final static int STYLESHEET_CSS               = 0x000200;
-    private final static int ALL                          = 0x0003ff;
-    private final static int TOP                          = ((ALL<<1)|1)&~ALL;
-    private final static String[] FILES = new String[] {
-        "overview-tree.html",
-        "index-all.html",
-        "deprecated-list.html",
-        "allclasses-frame.html",
-        "index.html",
-        "packages.html",
-        "overview-summary.html",
-        "package-list",
-        "help-doc.html",
-        "stylesheet.css",
-    };
-
-    private void wantFiles(int mods) {
-        mods &= (ALL | TOP);
-
-        for (int c = 0; mods != 0x1; c++, mods >>= 0x1) {
-            if ((mods & 0x1) == 0x1) {
-                wantFiles(FILES[c]);
-            } else {
-                avoidFiles(FILES[c]);
-            }
-        }
-    }
-
-    private int MODS = ALL;
-    private void avoid(int mods) {
-        MODS &= ~mods;
-    }
-
-    /**
-     * Make the doc dir -- e.g. call {@link #makeDocDir}
-     */
-    protected void beforeEveryTask() {
-        makeDocDir();
-        wantFiles(MODS);
-    }
-
-    /**
-     * Assert classes and clear doc dir.
-     *
-     * @see #checkDocs()
-     * @see #clearDocDir()
-     */
-    protected void afterEveryTask() {
-        checkDocs();
-        clearDocDir();
-        MODS = ALL;
-    }
-
-    protected void avoidFiles(String filesWithoutHtmlExtensions) {
-        List list = new ArrayList();
-        for (StringTokenizer tok =
-                 new StringTokenizer(filesWithoutHtmlExtensions, " ,;");
-             tok.hasMoreTokens();) {
-            list.add(tok.nextToken());
-        }
-        avoidFiles(list);
-    }
-
-    protected void avoidFiles(List filesWithoutHtmlExtensions) {
-        for (Iterator iter = filesWithoutHtmlExtensions.iterator(); iter.hasNext();) {
-            dont(iter.next()+"");
-        }
-    }
-
-    protected void wantFiles(String filesWithoutHtmlExtensions) {
-        List list = new ArrayList();
-        for (StringTokenizer tok =
-                 new StringTokenizer(filesWithoutHtmlExtensions, " ,;");
-             tok.hasMoreTokens();) {
-            list.add(tok.nextToken());
-        }
-        wantFiles(list);
-    }
-
-    protected void wantFiles(List filesWithoutHtmlExtensions) {
-        for (Iterator iter = filesWithoutHtmlExtensions.iterator(); iter.hasNext();) {
-            want(iter.next()+"");
-        }
-    }
-
-    protected void checkDocs() {
-        for (Iterator iter = wants.iterator(); iter.hasNext();) {
-            String filename = iter.next() + "";
-            File file = new File(docDir, filename);
-            if (file != null && file.exists()) {
-                have(filename);
-            } else {
-                //System.err.println("westodo expected " + file.getPath());
-            }
-        }
-        for (Iterator iter = donts.iterator(); iter.hasNext();) {
-            String filename = iter.next() + "";
-            File file = new File(docDir, filename);
-            if (file != null && file.exists()) {
-                have(filename);
-            } else {
-                //System.err.println("westodo avoiding " + file.getPath());
-            }
-        }
-    }
-
-    /**
-     * Create a new doc dir.
-     */
-    protected void init() {
-        docDir = new File(project.getBaseDir(), TEST_DOCDIR);
-    }
-
-    /**
-     * Make a new doc dir using ANT.
-     */
-    protected void makeDocDir() {
-        try {
-            Mkdir mkdir = (Mkdir)project.createTask("mkdir");
-            mkdir.setDir(docDir);
-            mkdir.execute();
-        } catch (BuildException be) {
-            be.printStackTrace();
-        }
-    }
-
-    /**
-     * Clear the build dir using ANT.
-     */
-    protected void clearDocDir() {
-        try {
-            Delete delete = (Delete)project.createTask("delete");
-            FileSet fileset = new FileSet();
-            fileset.setDir(docDir);
-            fileset.setIncludes("**");
-            delete.addFileset(fileset);
-            delete.execute();
-        } catch (BuildException be) {
-            be.printStackTrace();
-        }        
-    }
-
-    /**
-     * Invoke {@link #runTests(String[])} on a
-     * new instanceof {@link #AjdocTaskTester}.
-     *
-     * @param args Command line arguments.
-     */
-    public static void main(String[] args) {
-        new AjdocTaskTester().runTests(args);
-    }
-}
diff --git a/aspectj-attic/testing-src/AntTaskTester.java b/aspectj-attic/testing-src/AntTaskTester.java
deleted file mode 100644
index 1f032e74f..000000000
--- a/aspectj-attic/testing-src/AntTaskTester.java
+++ /dev/null
@@ -1,409 +0,0 @@
-/* *******************************************************************
- * 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) {
-    }
-}
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareFiles.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareFiles.java
deleted file mode 100644
index 2d16c9e6b..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareFiles.java
+++ /dev/null
@@ -1,571 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-
-import org.aspectj.util.LangUtil;
-
-import jdiff.util.Diff;
-import jdiff.text.FileLine;
-import jdiff.util.DiffNormalOutput;
-
-import java.util.*;
-import java.util.zip.*;
-import java.io.*;
-
-/**  
- * Compare two files and emit differences.
- * Requires the jdiff library in jdiff/jdiff.jar
- */
-public class CompareFiles {
-    protected static String[] NO_STRINGS = new String[]{};
-    /** standard rendering of null references */
-    public static final String NULL = "null";
-    /** filter for the both files  */
-    protected RegexpFilter filter;
-    /** ignore case by converting lines to upper case */
-    protected boolean ignoreCase  = false;
-    /** collapse internal whitespace by converting to space character */
-    protected boolean collapseWhitespace  = true;
-    /** trim leading and trailing whitespace from lines before comparison */
-    protected boolean trimWhitespace  = false;
-    /** output to this File - if not set, System.out */
-    protected File output  = null;
-
-    /**
-     * Compare two files by lines, emitting output to System.out as a series of edits.
-     * @param args  the String[] containing two files to diff plus any number of
-     *              <li>-i "ignore": ignore case</li>
-     *              <li>-t "trim"  : ignore leading and trailing white space</li>
-     *              <li>-b "blanks": ignore differences in all white space</li>
-     * @param lhs the File on the left-hand-side of the comparison
-     * @param rhs the File on the left-hand-side of the comparison
-     * @throws IllegalArgumentException if cannot read both files
-     */
-    public static void main(String[] args) {
-        new CompareFiles().comparefiles(args);
-    }
-
-    /**
-     * Write results of a diff to some output Writer
-     * @param result the DiffResult containing the results of the diff
-     * @param output the Writer to output results to - if null, 
-     *               defaults to System.out, but will be closed if not null
-     * @throws IllegalArgumentException if null == result or output 
-     */
-    public static void writeDiffResult(DiffResult result, File output) 
-        throws IOException {
-        if (null == result) throw new IllegalArgumentException("null result");
-        Writer writer = (null != output ? new FileWriter(output) 
-            : new OutputStreamWriter(System.out));
-        DiffNormalOutput out = new DiffNormalOutput(result.lhsLines, result.rhsLines);
-        out.setOut(writer);
-        out.setLineSeparator(LangUtil.EOL);
-        try {
-            out.writeScript(result.edits);
-        } finally {
-            if (null != output) {
-                try { writer.close(); } 
-                catch (IOException e) {
-                    e.printStackTrace(System.err);
-                }
-            }
-        }
-    } // writeDiffResult
-
-    /**
-     * descend filesystem tree, invoking FileRunnerI.accept() on files.
-     * E.g., To list files from current directory:
-     * <code><pre>descendFileTree(new File("."), new FileRunnerI() {
-     *     public boolean accept(File f){
-     *        System.out.println(f.getAbsolutePath());
-     *        return true;
-     *     }});</code></pre>
-     * @param file root/starting point.  If a file, the only one visited.
-     * @param filter supplies accept(File) routine
-     */
-    public static void descendFileTree(File file, FileFilter filter) {
-        descendFileTree(file, filter, false);
-    }
-
-    /**
-     * Descend filesystem tree, invoking FileFilter.accept() on files
-     * and, if userRecursion, on dirs. If userRecursion, accept() must
-     * call descendFileTree() again to recurse down directories.
-     * This calls fileFilter.accept(File) on all files before doing any dirs.
-     * E.g., To list only files from Unix root:
-     * <code><pre>descendFileTree(new File("/"), new FileFilter() {
-     *     public boolean run(File f){
-     *        System.out.println(f.getAbsolutePath());
-     *        return true;
-     *     }}, false);</code></pre>
-     * To list files/dir from root using user recursion:
-     * <code><pre>descendFileTree(new File("/"), new FileFilter() {
-     *     public boolean run(File f){ 
-     *        System.out.println(f.getAbsolutePath());
-     *        if (f.isDirectory() && (-1 == f.getName().indexOf("CVS")))
-     *           return descendFileTree(f, this, true);
-     *        return true;
-     *     }}, true);</code></pre>
-     * @param file root/starting point.  If a file, the only one visited.
-     * @param filter supplies boolean accept(File) method
-     * @param userRecursion - if true, do accept() on dirs; else, recurse
-     * @return false if any fileFilter.accept(File) did.
-     * @throws IllegalArgumentException if file or fileFilter is null
-     */
-    public static boolean descendFileTree(File file, FileFilter fileFilter, 
-                                          boolean userRecursion) {
-        if (null == file) {throw new IllegalArgumentException("parm File"); }
-        if (null == fileFilter){throw new IllegalArgumentException("parm FileFilter");}
-
-        if (!file.isDirectory()) {
-            return fileFilter.accept(file);
-        } else if (file.canRead()) { 
-            // go through files first
-            File[] files = file.listFiles(ValidFileFilter.FILE_EXISTS); 
-            if (null != files) {
-                for (int i = 0; i < files.length; i++) {
-                    if (!fileFilter.accept(files[i])) {
-                        return false;
-                    }
-                }
-            }
-            // now recurse to handle directories
-            File[] dirs = file.listFiles(ValidFileFilter.DIR_EXISTS);
-            if (null != dirs) {
-                for (int i = 0; i < dirs.length; i++) {
-                    if (userRecursion) {
-                        if (!fileFilter.accept(dirs[i])) {
-                            return false;
-                        }
-                    } else {
-                        if (!descendFileTree(dirs[i], fileFilter,userRecursion)) {
-                            return false;
-                        }
-                    }
-                }
-            }
-        } // readable directory (ignore unreadable ones) 
-        return true;
-    } // descendFiles
-
-    /**
-     * Render a zip/entry combination to String
-     */
-    private static String renderZipEntry(File zipfile, ZipEntry entry) {
-        String filename = (null == zipfile ? "null File" : zipfile.getName());
-        String entryname = (null == entry ? "null ZipEntry" : entry.getName());
-        //return filename + "!" + entryname;
-        return "" + entryname;
-    }
-
-    /**
-     * Initialise the filter.  Users must do this before the filter is
-     * lazily constructed or must set update to true.
-     * @param args the String with any args valid for RegexpFilter.init(String, RegexpFilter)
-     * @param update if true, use existing filter settings unless
-     *            overwritten by the new ones;
-     *            if false, create a new filter using args.
-     * @throws IllegalArgumentException if cannot read both files
-     * @see RegexpFilter#init(String, RegexpFilter)
-     */
-    public void initFilter(String arg, boolean update) {
-        filter = RegexpFilter.init(arg, update ? filter : null);
-    }
-
-    /**
-     * Initialise the filter.  Users must do this before the filter is
-     * lazily constructed or must set update to true.
-     * @param args the String[] with any args valid for RegexpFilter
-     * @param update if true, use existing filter settings unless
-     *            overwritten by the new ones;
-     *            if false, create a new filter using args.
-     * @throws IllegalArgumentException if cannot read both files
-     * @see RegexpFilter#init(String[], RegexpFilter)
-     */
-    public void initFilter(String[] args, boolean update) {
-        filter = RegexpFilter.init(args, update ? filter : null);
-    }
-
-    /**
-     * Compare two files by lines, emitting output to System.out as a series of edits.
-     * @param args  the String[] containing two files to diff 
-     *              (lhs, rhs) plus any args valid for RegexpFilter
-     * @throws IllegalArgumentException if cannot read both files
-     */
-    public final void comparefiles(String[] args) {
-        if (errMessage(null == args, "null args", null)) return;
-        if (errMessage(args.length < 2, "need more args", null)) return;
-        File lhs = new File(args[0]);
-        File rhs = new File(args[1]);
-        if (errMessage(!lhs.canRead(), "!lhs.canRead()", null)) return;
-        if (errMessage(!rhs.canRead(), "!rhs.canRead()", null)) return;
-        int filterArgsLength = args.length - 2;
-        if (0 >= filterArgsLength) {
-            initFilter(NO_STRINGS, false);
-        } else {
-            String[] filterArgs = new String[filterArgsLength];
-            System.arraycopy(args, 0, filterArgs, 0, filterArgsLength);
-            initFilter(filterArgs, false);
-        }
-        
-        try {
-            if (errMessage(!diff(lhs, rhs), "diff(lhs,rhs)",null)) return;
-        } catch (IOException t) {
-            if (errMessage(false, null, t)) return;
-        }
-    } // main
-
-    /**
-     * Compare two files/dirs, emitting output as a series of edits.
-     * If both files are directories, then this compares their contents
-     * (including the contents of any zip or jar files) as a series of paths
-     * (i.e., it will recognize added or removed or changed filenames, but
-     * not files whose contents have changed).
-     * Output will go to the File specifies as "output" or System.out if none specified.
-     * This is costly, creating an in-memory copy, one String per line, of both files.
-     * @param lhs the File/dir on the left-hand-side of the comparison
-     * @param rhs the File/dir on the left-hand-side of the comparison
-     * @throws IllegalArgumentException if either parm is null or not existing,
-     *         or if one is a dir and the other a file
-     * @throws IOException if getFileLines or diff utilities do
-     * @return false if there was some error
-     */
-    public final boolean diff(File lhs, File rhs) throws IOException {
-        DiffResult result = null;
-        String err = null;
-        if ((null == lhs) || (null == rhs) 
-            || (!lhs.exists()) || (!rhs.exists()) 
-            || (!lhs.canRead()) || (!rhs.canRead()) 
-            || (lhs.isDirectory() != rhs.isDirectory())) {
-            err = "need 2 readable files or dirs or zip files - got lhs=" + lhs + " rhs=" + rhs;
-        } else if (lhs.isDirectory()) {
-            result = diffDirUtil(lhs, rhs);
-        } else {
-            boolean lhsIsZip = isZipFile(lhs);
-            if (lhsIsZip != isZipFile(rhs)) {
-                err = "need 2 readable files or dirs or zip files - got lhs=" + lhs + " rhs=" + rhs;
-            } else if (lhsIsZip) {
-                result = diffDirUtil(lhs, rhs);
-            } else {
-                result = diffUtil(lhs, rhs);
-            }
-        }
-        if (null != err) throw new IllegalArgumentException(err);
-        if (errMessage(null == result, null, null)) return false;
-        writeDiffResult(result, output);
-        return true;
-    }
-
-    /**
-     * Compare two files, returning results for further evaluation or processing
-     * @param lhs the File on the left-hand-side of the comparison
-     * @param rhs the File on the left-hand-side of the comparison
-     * @throws IllegalArgumentException if either parm is null
-     * @throws IOException if getFileLines or diff utilities do
-     * @return false if there was some error
-     */
-    public final DiffResult diffUtil(File lhs, File rhs) 
-        throws IOException {
-        if (errMessage(null == lhs, "null lhs", null)) return null;
-        if (errMessage(null == rhs, "null rhs", null)) return null;
-        FileLine[] lhsLines = getFileLines(lhs);
-        FileLine[] rhsLines = getFileLines(rhs);
-        Diff.change edits = new Diff(lhsLines, rhsLines).diff_2(false);
-        return new DiffResult(lhsLines, rhsLines, edits);
-    }
-
-    /**
-     * Read all lines of a file into a String[] (not very efficient),
-     * implementing flag policies.
-     * @param file the File to read
-     * @return a FileLine[] with elements for each line in the file
-     */
-    public FileLine[] getFileLines(File file) throws IOException {
-        if (file.isDirectory()) return getFileLinesForDir(file);
-        final Vector results = new Vector();
-        
-        BufferedReader in = null;
-        try {
-            in = getReader(file);
-            String line;
-            while (null != (line = in.readLine())) { 
-                results.add(toFileLine(line));
-            }
-        } finally {
-            if (null != in) { in.close(); } 
-        }
-        final FileLine[] lines = new FileLine[results.size()];
-        results.copyInto(lines);
-        return lines;
-    }
-    
-    /**
-     * Compare two directories or zip files by listing contents (including contents of zip/jar files) 
-     * and differencing the results.  This does NOT call diff on each file, but only
-     * recognizes when files or zip entries have been added or removed.
-     * @param lhsDir the File for an existing, readable directory (as left-hand-side)
-     * @param rhsDir the File for an existing, readable directory (as right-hand-side)
-     * @throws IllegalArgumentException if null == lhs or rhsDir 
-     */
-    public DiffResult diffDirUtil(File lhsDir, File rhsDir) {
-        FileLine[] lhsLines = getFileLinesForDir(lhsDir);
-        FileLine[] rhsLines = getFileLinesForDir(rhsDir);
-        // now do the comparison as if they were two files
-        Diff.change edits = new Diff(lhsLines, rhsLines).diff_2(false);
-        return new DiffResult(lhsLines, rhsLines, edits);
-    } 
-    
-    /**
-     * Render all sub-elements of a directory as a list of FileLine[], including entries 
-     * in zip and jar files.  The directory prefix is not included in the FileLine.
-     * @param dir the File representing the directory to list
-     * @throws IllegalArgumentException if null == dir  or !dir.isDirectory()
-     */
-    public FileLine[] getFileLinesForDir(File dir) {
-        if (null == dir) throw new IllegalArgumentException("null dir");
-        if (!dir.isDirectory() && ! isZipFile(dir)) throw new IllegalArgumentException("not a dir: " + dir);
-        Collection items = directoryToString(dir, null);
-        return toFileLine(items, dir.getPath(), true);
-    } 
-
-    /** @return true if test or if null != error */
-    protected boolean errMessage(boolean test, String message, Throwable error) {
-        if (test && (null != message)) { System.err.println(message); }
-        if (null != error) { error.printStackTrace(System.err); }
-        return (test || (null != error));
-    }
-
-    /**
-     * Convert current setting into an initialization list for filter
-     */
-    protected String[] getFilterArgs() {
-        return new String[] 
-            { (trimWhitespace     ? "-t" : "-T")
-            , (collapseWhitespace ? "-b" : "-B")
-            , (ignoreCase         ? "-i" : "-I")
-            };
-    }
-
-    /**
-     * Lazy construction of filter
-     */
-    protected RegexpFilter getFilter() {
-        if (null == filter) {
-            filter = RegexpFilter.init(getFilterArgs(), null);
-        }
-        return filter;
-    }
-
-    /**
-     * Factory for reader used by getFileLines(File).
-     * Default implementation creates a BufferedReader.
-     * Subclasses may implement pre-processing filters here.
-     */
-    protected BufferedReader getReader(File file) throws IOException {
-        return new BufferedReader(new FileReader(file));
-    }
-
-    /**
-     * Create a FileLine from the input string,
-     * applying policies for whitespace, etc.
-     * @param string the String to wrap as a FileLine
-     * @return FileLine with string as text and 
-     *        canonical as string modified by any canonicalizing policies.
-     */
-    protected FileLine toFileLine(String string) {
-        String canonical = getFilter().process(string);
-        return new FileLine(string, canonical);
-    }
-
-
-    protected boolean isZipFile(File f) {
-        String s = null;
-        if ((null == f)  || (null == (s = f.getPath()))) {
-            return false;
-        } else {
-            return (f.exists() && !f.isDirectory() && (s.endsWith(".jar")));
-        }
-    }
-
-    /**
-     * Convert to an array of FileLine by optionally removing prefix and/or sorting
-     * @param collection the Collection of String to process
-     */
-    protected FileLine[] toFileLine(Collection collection, String ignorePrefix, boolean sort) {
-        if (null == collection) throw new IllegalArgumentException("null collection");
-        List list = new ArrayList();
-        list.addAll(collection);
-        if (null != ignorePrefix) {
-            for (int i = 0; i < list.size(); i++) {
-                String next = list.get(i).toString();
-                if (next.startsWith(ignorePrefix)) {
-                    list.set(i, next.substring(ignorePrefix.length()));
-                }
-            }
-        }
-        if (sort) {
-            Collections.sort(list);
-        }
-        FileLine[] result = new FileLine[list.size()];
-        int i = 0;
-        for (Iterator it = list.iterator(); it.hasNext();) {
-            result[i++] = toFileLine(it.next().toString());
-        }
-        if (i < result.length) {
-            throw new Error("list lost elements? " + (result.length-i)); 
-        }
-        return result;
-    }
-
-    /**
-     * Return the names of all files below a directory.
-     * If file is a directory, then all files under the directory
-     * are returned.  If file is absolute or relative, all the files are.
-     * If file is a zip or jar file, then all entries in the zip or jar
-     * are listed.  Entries inside those jarfiles/zipfiles are not listed.
-     * There are no guarantees about ordering.
-     * @param dir the File to list for
-     * @param results the Collection to use for the results (may be null)
-     * @throws IllegalArgumentException if null == dir 
-     * @return a Collection of String of paths, including paths inside jars
-     */
-    protected Collection directoryToString(File dir, Collection results) {
-        if (null == dir) throw new IllegalArgumentException("null dir");
-        final Collection result = (results != null? results : new Vector());
-        if (isZipFile(dir)) {
-            zipFileToString(dir, result);
-        } else if (!dir.isDirectory()) {
-            throw new IllegalArgumentException("not a dir: " + dir);
-        } else {
-            AccumulatingFileFilter acFilter = new AccumulatingFileFilter() {
-                    public boolean accumulate(File file) {
-                        String name = file.getPath();
-                        result.add(name);
-                        if (isZipFile(file)) {
-                            zipFileToString(file, result);
-                        }
-                        return true;
-                    }
-                };
-            descendFileTree(dir, acFilter, false);
-        }
-        return result;
-    } // directoryToString
-
-    /**
-     * Render as String the entries in a zip or jar file,
-     * converting each to String beforehand (as jarpath!jarentry)
-     * applying policies for whitespace, etc.
-     * @param file the File to enumerate ZipEntry for
-     * @param results the Colection to use to return the FileLine - may be null
-     * @return FileLines with string as text and 
-     *        canonical as string modified by any canonicalizing policies.
-     */
-    protected Collection zipFileToString(final File zipfile, Collection results) {
-        Collection result = (results != null ? results : new Vector());
-        ZipFile zip = null;
-        try {
-            //ZipFile.OPEN_READ | ZipFile.OPEN_DELETE); delete is 1.3 only
-            zip = new ZipFile(zipfile); 
-            Enumeration enum = zip.entries();
-            // now emitting filename only once, so entries match even if filename does not
-            results.add("ZipFileName: " + zipfile);
-            while (enum.hasMoreElements()) {
-                results.add(renderZipEntry(zipfile, (ZipEntry) enum.nextElement()));
-            }
-            zip.close();
-            zip = null;
-        } catch (Throwable t) {
-            String err = "Error opening " + zipfile + " attempting to continue...";
-            System.err.println(err);
-            t.printStackTrace(System.err);
-        } finally {
-            if (null != zip) {
-                try { zip.close(); }
-                catch (IOException e) {
-                    e.printStackTrace(System.err);
-                }
-            }
-        }
-        return result;
-    }
-
-    /** 
-     * return structure for diffUtil 
-     */
-    public final class DiffResult {
-        public final FileLine[] lhsLines;
-        public final FileLine[] rhsLines;
-        public final Diff.change edits;
-        public DiffResult (FileLine[] lhsLines,
-                           FileLine[] rhsLines,
-                           Diff.change edits) {
-            this.lhsLines = lhsLines;
-            this.rhsLines = rhsLines;
-            this.edits = edits;
-        }
-    }
-
-} // class CompareFiles
-
-class ValidFileFilter implements FileFilter {
-    public static final FileFilter EXIST = new ValidFileFilter();
-    public static final FileFilter FILE_EXISTS = new FilesOnlyFilter();
-    public static final FileFilter DIR_EXISTS = new DirsOnlyFilter();
-    protected ValidFileFilter(){}
-    public boolean accept(File f) {
-        return ((null != f) && (f.exists()));
-    }
-    static class FilesOnlyFilter extends ValidFileFilter {
-        public final boolean accept(File f) {
-            return (super.accept(f) && (!f.isDirectory()));
-        }
-    }
-    static class DirsOnlyFilter extends ValidFileFilter {
-        public final boolean accept(File f) {
-            return (super.accept(f) && (f.isDirectory()));
-        }
-    }
-}
-
-/** 
- * A FileFilter that accumulates the results when called if they exist.
- * Subclasses override accumulate to determine whether it should be
- * accumulated.
- */
-class AccumulatingFileFilter extends ValidFileFilter {
-    Vector files = new Vector();
-    public final boolean accept(File f) {
-        if (super.accept(f) && (accumulate(f))) {
-            files.add(f);
-        }
-        return true;
-    }
-
-    /** 
-     * This implementation accumulates everything.
-     * Subclasses should override to implement filter
-     * @param file a File guaranteed to exist 
-     * @return true if file should be accumulated. 
-     */
-    public boolean accumulate(File f) {
-        return true;
-    }
-    /**
-     * @return list of files currently accumulated 
-     */
-    public File[] getFiles() {
-        return (File[]) files.toArray(new File[0]);
-    }
-}
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareUtil.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareUtil.java
deleted file mode 100644
index 8358a177d..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareUtil.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-
-import java.util.Iterator;
-import java.util.Collection;
-import java.util.List;
-
-/** Minor methods for short-circuiting comparisons */
-public class CompareUtil {    
-    /**
-     * Callers may abort equality checks with false
-     * if this passes its misc short-circuit semantics.
-     * A false result does not mean the arguments
-     * are equal, but a true result does mean they are not equal. 
-     * <pre>if (notSame(foo,bar,true)) then return false;</pre>
-     * @param lhs the Object on the left-hand-side to compare
-     * @param rhs the Object on the right-hand-side to compare
-     * @param considerType if true, then also return true if the 
-     *           right-hand-side cannot be assigned to the left-hand-side
-     * @return true if lhs and rhs are not the same per considerType.
-     */
-    public static boolean notSame(Object lhs, Object rhs, boolean considerType) {
-        if (null == lhs) {
-            return (!(null == rhs));
-        } else if (null == rhs) {
-            return true;
-        } else if (lhs== rhs) {
-            return false;  // known to be same
-        } else if (considerType) {
-            Class lhClass = lhs.getClass();
-            Class rhClass = rhs.getClass();
-            if (!lhClass.isAssignableFrom(rhClass)) {
-                return true;
-            }
-        }
-        return false; // unknown whether equal or not
-    }    
-
-    /**
-     * Return null/equal comparison:
-     * <li>null considered to be lesser</li>
-     * <li>reference or Object.equals() considered to be 0</li>
-     * <li>return Integer.MAX_VALUE for all other cases</li>
-     * <table>
-     * <tr><td>result</td><td>input</td></tr>
-     * <tr><td>-1</td><td>null &lt; rhs</td></tr>
-     * <tr><td>1</td><td>lhs &gt; null</td></tr>
-     * <tr><td>0</td><td>null == null</td></tr>
-     * <tr><td>0</td><td>lhs == rhs</td></tr>
-     * <tr><td>0</td><td>lhs.equals(rhs)</td></tr>
-     * <tr><td>Integer.MAX_VALUE</td><td>{all other cases}</td></tr>
-     * </table>
-     * @see Comparator
-     * @return Integer.MAX_VALUE if uncertain, value otherwise
-     */
-    public static int compare(Object lhs, Object rhs) {
-        if (null == lhs) {
-            return (null == rhs ? 0 : -1);
-        } else if (null == rhs) {
-            return 1;
-        } else if (lhs == rhs) {
-            return 0;  // known to be same
-        } else {
-            return Integer.MAX_VALUE;
-        }
-    }
-
-    /**
-     * Return boolean comparison where true > false.
-     * (Comparable not defined for Boolean)
-     * @see Comparator
-     */
-    public static int compare(boolean lhs, boolean rhs) {
-        return (lhs == rhs ? 0 : (lhs ? 1 : -1));
-    }
-
-    /**
-     * Return String comparison based on {@link compare(Object,Object)}
-     * and {@link String.compareTo(String)}.
-     * @see Comparator
-     */
-    public static int compare(String lhs, String rhs) {
-        int result = compare((Object) lhs, (Object) rhs);
-        if (Integer.MAX_VALUE == result) {
-            result = lhs.compareTo(rhs);
-        }
-        return result;
-    }
-
-    /**
-     * Compare two Collections by reference to a standard List.
-     * The first Collection to not contain a standard element 
-     * when the other does loses. Order is ignored.
-     * The left-hand-side acts as the standard if the standard is null.
-     * @param lhs the List from the left-hand-side
-     * @param rhs the Collection from the right-hand-side
-     * @param standard the List to act as the standard (if null, use lhs)
-     * @param return -1 if lhs is null and rhs is not, 1 if reverse;
-     *        0 if both have all elements in standard,
-     *        1 if lhs has a standard element rhs does not, -1 if reverse
-     *        (testing in standard order)
-     */
-    public static int compare(List lhs, Collection rhs, List standard) {
-        int result = compare(lhs, rhs);
-        if (result == Integer.MAX_VALUE) {
-            if (null == standard) {
-                result = compare(lhs, rhs, lhs); // use lhs as standard
-            } else {
-                boolean leftHasThem = lhs.containsAll(standard);
-                boolean rightHasThem = rhs.containsAll(standard);
-                if (leftHasThem != rightHasThem) {
-                    result = (leftHasThem ? 1 : -1);
-                } else if (leftHasThem) {
-                    result = 0; // they both have them
-                } else {        // first to not have an element loses
-                    Iterator standardIterator = standard.iterator();
-                    while (standardIterator.hasNext()) {
-                        Object standardObject = standardIterator.next();
-                        boolean leftHasIt = lhs.contains(standardObject);
-                        boolean rightHasIt = rhs.contains(standardObject);
-                        if (leftHasIt != rightHasIt) {
-                            result = (leftHasIt ? 1 : -1);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    }
-} // class Util
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNode.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNode.java
deleted file mode 100644
index cdb0b70da..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNode.java
+++ /dev/null
@@ -1,427 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-
-package org.aspectj.testing.compare;
-
-import java.util.*;
-
-
-/** 
- * Generic tree and pairwise traversal over it
- * for comparison purposes.
- * Implement a generic tree by delegation and
- * a traversal method for comparing two trees.
- * Guarantees after initialization:
- * <li>nodeComparator is not null</li>
- * <li>node is not null</li>
- * <li>children, if any, are assignable to childClass 
- *     (only as of initialization, since list is adopted)</li>
- * <li>Obeys GenericTreeNode contract, especially regarding equals</li>
- * <p>It will throw Error if used before initialization completes.
- */
-public class GenericTreeNode implements Comparable {
-    /** underlying node - never null */
-    Object node; 
-    /** node children - type-safe if present */
-    List children;
-    /** node parent - may be null if this is tree root */
-    GenericTreeNode parent;
-    /** used to compare underlying node */
-    Comparator nodeComparator;
-    /** Class used to verify children  - may be null */
-    Class childClass;
-
-    /** Track whether we are initialized */
-    boolean ready;
-    /** cache for heavy toString() */
-    String toStringCache;
-
-    // --------------------------------------- static
-    /** Singleton visitor to match trees exactly, stopping at first failure */
-    public static final GenericTreeNodesVisitorI EXACT = new MatchExact();
-
-    /** Singleton visitor to print non-matching nodes to System.err */
-    public static final GenericTreeNodesVisitorI PRINTERR = new PrintNonMatches();
-
-    /** Singleton visitor to print all nodes to System.err */
-    public static final GenericTreeNodesVisitorI PRINTALL = new PrintAllPairs();
-
-
-    /** Singleton comparator for all of us */
-    public static final Comparator COMPARATOR = new gtnComparator();
-
-    /**
-     * Visit two generic trees in order.
-     * Visit the parents, and recursively visit the children.
-     * The children are visited in an order determined by 
-     * (any) ordering factory invoked to produce an ordered pair
-     *  of children lists for visiting.
-     * All children are visited, even if not paired.
-     * When one list of children is smaller, the 
-     * remainder are visited with null complements.
-     * This is true for parents as well; this will visit
-     * all the children of a parent even when the 
-     * other parent is null.
-     * This will return false without further visits 
-     * as soon as the visitor returns false.  That means
-     * the visitor can decide to stop visiting when null
-     * nodes (parent or children) are encountered).
-     * This will return true only after the tree was
-     * visited without objection from the visitor.
-     * <p>A simple example of using this to determine if
-     * two trees are strictly equal is this:
-     * @return false if the visitor returned false for any visit;
-     *         true otherwise.
-     * @throws Error if any children are not GenericTreeNode
-     * @throws IllegalArgumentException if the visitor or both parents are null
-     */
-
-    public static boolean traverse(GenericTreeNode lhsParent
-                                   , GenericTreeNode rhsParent
-                                   , GenericTreeNodeListOrdererFactoryI childrenPrepFactory
-                                   , GenericTreeNodesVisitorI visitor) {
-        if (null == visitor) {
-            throw new IllegalArgumentException("null visitor");
-        }
-        if ((null == lhsParent) && (null == rhsParent)) {
-            throw new IllegalArgumentException("null parents");
-        }
-        if (visitor.visit(lhsParent, rhsParent)) {
-            List lhsList = (null == lhsParent ? null : lhsParent.getChildren());
-            List rhsList = (null == rhsParent ? null : rhsParent.getChildren());
-            if (null != childrenPrepFactory) {
-                GenericTreeNodeListOrdererI factory = 
-                    childrenPrepFactory.produce(lhsParent, rhsParent, visitor);
-                if (null !=  factory) {
-                    List[] prepKids = factory.produceLists(lhsList, rhsList);
-                    if (null != prepKids) {
-                        lhsList = prepKids[0];
-                        rhsList = prepKids[1];
-                    }
-                }
-                
-            }
-            ListIterator lhsIterator = (null == lhsList ? null : lhsList.listIterator());
-            ListIterator rhsIterator = (null == rhsList ? null : rhsList.listIterator());
-            Object lhs = null;
-            Object rhs = null;
-            while (true) {
-                lhs = null;
-                rhs = null;
-                // get the child pair
-                if ((null != lhsIterator) && (lhsIterator.hasNext())) {
-                    lhs = lhsIterator.next();
-                }
-                if ((null != rhsIterator) && (rhsIterator.hasNext())) {
-                    rhs = rhsIterator.next();
-                }
-                if ((null == rhs) && (null == lhs)) {
-                    break;
-                }
-                if ((null != lhs) && (!(lhs instanceof GenericTreeNode))) {
-                    throw new Error("GenericTreeNode expected, got lhs " + lhs);
-                } 
-                if ((null != rhs) && (!(rhs instanceof GenericTreeNode))) {
-                    throw new Error("GenericTreeNode expected, got rhs " + rhs);
-                }
-                // traverse the child pair
-                if (!traverse((GenericTreeNode) lhs, (GenericTreeNode) rhs, 
-                              childrenPrepFactory, visitor)) {
-                    return false;
-                }
-            }
-        }
-        return true; // see also other return statements above
-    }     // traverse
-
-    // --------------------------------------- constructors
-    public GenericTreeNode() {
-        //ready = false;
-    }
-
-    public void init(GenericTreeNode parent, Comparator nodeComparator, 
-                     Object node, List children, Class childClass) {
-        if (ready) ready = false; // weak sync
-        if (null == node) {
-            throw new IllegalArgumentException("null node");
-        }
-        if (null == nodeComparator) {
-            throw new IllegalArgumentException("null nodeComparator");
-        }
-        this.nodeComparator = nodeComparator;
-        this.node = node;
-        this.children = children;
-        this.parent = parent;
-        if (null != childClass) {
-            ListIterator iter = children.listIterator();
-            while (iter.hasNext()) {
-                Object kid = iter.next();
-                if (!(childClass.isAssignableFrom(kid.getClass()))) {
-                    String err = "child " + kid + " is not " + childClass;
-                    throw new IllegalArgumentException(err);
-                }
-            }
-            this.childClass = childClass;
-        }
-        ready = true;
-    }
-
-    //-------------------- Object interface
-    /** 
-     * ambiguous: equal if 
-     * <li>this is the input, or </li>
-     * <li>the input is a GenericTreeNode, and </li>
-     * <li>the underlying nodes are equal(), or</li
-     * <li>the underlying nodes have equal comparators
-     *     which return 0 from compare(...)</li>
-     * @param input the Object to compare with
-     * @return true if this equals input
-     */
-    public boolean equals(Object input) {
-        if (input == this) {
-            return true;
-        } else if (!(input instanceof GenericTreeNode)) {
-            return false;
-        } else {
-            GenericTreeNode in = (GenericTreeNode) input;
-            if (node.equals(in.getNode())) { // assumes nodes are unique, not flyweights?
-                return true;
-            } else {
-                Comparator inComp = in.getNodeComparator();
-                if ((this == nodeComparator) 
-                    || (this == inComp)
-                    || (nodeComparator == inComp) 
-                    || (nodeComparator.equals(inComp))) {
-                    return (0 == nodeComparator.compare(this, in));
-                } else {
-                    return false;
-                }
-            }
-        }
-    }
-
-    /** 
-     * Delegate to the underlying node object 
-     * @return the hashcode of the underlying node object  
-     */
-    public int hashCode() { // todo: probably not correct to delegate to node
-        return node.hashCode();
-    }
-
-    /** toString delegates to longString() */ 
-    public String toString() {
-        if (null == toStringCache) {
-            toStringCache = longString();
-        }
-        return toStringCache;
-    }
-
-    /** 
-     * short rendition delegates to thisString,
-     * prefixing by one tab per parent
-     */
-    public String shortString() {
-        StringBuffer sb = new StringBuffer();
-        // add a tab for each parent
-        GenericTreeNode par = parent;
-        while (null != par) {
-            sb.append("\t");
-            par = par.getParent();
-        } 
-        sb.append(thisString());
-        return sb.toString();
-    }
-
-    /** 
-     * long rendition delegates to parentString, thisString,
-     * and childString as follows:
-     * <pre>GenericTreeNode [parent={parentString()] [children={size}] [Node={thisString()]</pre>
-     */
-    public String longString() {
-        StringBuffer sb = new StringBuffer();
-        sb.append("GenericTreeNode ");
-        sb.append("[parent=");
-        sb.append(parentString());
-        sb.append("] [children=");
-        if (null == children) {
-            sb.append("0");
-        } else {
-            sb.append("" + children.size());
-        }
-        sb.append("] [Node=");
-        sb.append(thisString());
-        sb.append("]");
-        return sb.toString();
-    }
-
-    /** render this as "[root] [next] ... [parent]" */
-    protected String thisString() {
-        return node.toString();
-    }
-
-    /** render parent hierarchy as "[root] [next] ... [parent]" */
-    protected String parentString() {
-        if (null == parent) {
-            return "[null]";
-        } else  {
-            Vector parents = new Vector();
-            GenericTreeNode par = parent;
-            do {
-                parents.addElement(par);
-                par = par.getParent();
-            } while (null != par); 
-            int size = parents.size();
-            StringBuffer sb = new StringBuffer(32*size);
-            par = (GenericTreeNode) parents.remove(--size);
-            sb.append("[");
-            do {
-                sb.append(par.toString());
-                par = (size<1?null:(GenericTreeNode) parents.remove(--size));
-                if (null != par) {
-                    sb.append("] [");
-                }
-            } while (null != par);
-            sb.append("]");
-            return sb.toString();
-        }
-    } // parentString()
-
-    // -------------------------- Comparable interface
-    /**
-     * Comparable just delegates to Comparator.
-     * i.e., <code>return compare(this, rhs)</code>
-     * @param rhs the Object to compare from the right 
-     * @throws ClassCastException if either is not instanceof GenericTreeNode
-     * @return 0 if equal, &gt;0 if this is greater than rhs, &lt;0 otherwise.
-     */
-    public int compareTo(Object rhs) { 
-        return COMPARATOR.compare(this, rhs);
-    }
-
-
-    //-------------------- GenericTreeNode interface
-    /** @return the actual underlying node */
-    public Object getNode() { assertReady(); return node ; }
-    /** @return the actual underlying node */
-    public GenericTreeNode getParent() { assertReady(); return parent ; }
-    /** @return List of children - null if none */
-    public List getChildren() { assertReady(); return children ; }
-    /** @return Comparator used for comparing node (not children) */
-    public Comparator getNodeComparator() { assertReady(); return nodeComparator; }
-    /** @return Class which any children can be assigned to */
-    public Class getChildClass() { assertReady(); return childClass; }
-
-    //-------------------- misc
-    protected void assertReady() {
-        if (!ready) throw new Error("not ready");
-    }    
-
-    //-------------------- inner classes
-    /**
-     * This relies entirely on the GenericTreeNode implementation of equals()
-     * which delegates to the underlying node equals() or the comparator
-     */
-    static class MatchExact implements GenericTreeNodesVisitorI {
-        public boolean visit(GenericTreeNode lhs,GenericTreeNode rhs) {
-            return (null == lhs ? (null == rhs) : lhs.equals(rhs));
-        }
-    }
-
-    /**
-     * This prints non-matching pairs to System.err,
-     * returning true always.
-     */
-    static class PrintNonMatches implements GenericTreeNodesVisitorI {
-        public boolean visit(GenericTreeNode lhs,GenericTreeNode rhs) {
-            if (! (null == lhs ? (null == rhs) : lhs.equals(rhs))) {
-                System.err.println("[lhs=" + lhs + "] [rhs=" + rhs + "]");
-            }
-            return true;
-        }
-    }    
-
-    /**
-     * This prints all pairs to System.err, returning true always.
-     */
-    static class PrintAllPairs implements GenericTreeNodesVisitorI {
-        public boolean visit(GenericTreeNode lhs,GenericTreeNode rhs) {
-            System.err.println("[lhs=" + lhs + "] [rhs=" + rhs + "]");
-            return true;
-        }
-    }    
-
-    /**
-     * have to separate to distinguish
-     * gtn.equals() from gtnComparator.equals
-     */
-    static class gtnComparator implements Comparator {
-        public boolean equals(Object o) {
-            if (null == o) return false;
-            return ( o instanceof gtnComparator );
-        }
-        public int hashCode() {
-            return gtnComparator.class.hashCode();
-        }
-        // -------------------------- Comparator interface
-        /**
-         * Shallow compare of two GenericTreeNodes.
-         * <li>any null component translates to "less than" another null component<li>
-         * <li>comparators must be equal according to
-         *   <code>Comparator.equals(Comparator)</code><li>
-         * <li>underlying nodes equal according to
-         *    <code>Comparator.compare(Object lhs, Object rhs)</code><li>
-         * <li>if the two comparators are not equal, then
-         *     do arbitrary ordering of the node by toString().compareTo()
-         *     of the underlying objects</li>
-         * <li>children are ignored.  Two nodes may be equal even if
-         *     they do not have the same children.</li>
-         * @param lhs the Object to compare from the left 
-         * @param rhs the Object to compare from the right 
-         * @throws ClassCastException if either is not instanceof GenericTreeNode
-         */ 
-        public int compare(Object lhs, Object rhs) { 
-            int result = CompareUtil.compare(lhs, rhs);
-            if (Integer.MAX_VALUE == result) {
-                GenericTreeNode lhsNode = (GenericTreeNode) lhs;
-                GenericTreeNode rhsNode = (GenericTreeNode) rhs;
-                Object lhObject = lhsNode.getNode();
-                Object rhObject = rhsNode.getNode();
-                result = CompareUtil.compare(lhObject, rhObject); //
-                if (Integer.MAX_VALUE == result) {
-                    Comparator lhComp = lhsNode.getNodeComparator();
-                    Comparator rhComp = rhsNode.getNodeComparator();
-                    result = CompareUtil.compare(lhComp, rhComp);
-                    if ((Integer.MAX_VALUE == result)
-                        || ((0 == result) && (null == lhComp))) {
-                        // tricky: comparators are not equal or null, - todo
-                        // so unable to determine standard of ordering.
-                        // impose a consistent but arbitrary ordering
-                        // on the underlying objects
-                        System.err.println(" -- result: " + result + " lhComp " + lhComp);
-                        result = lhObject.toString().compareTo(rhObject.toString());
-                    } else if (0 == result) { // ok to use comparator
-                        result = lhComp.compare(lhsNode.getNode(), rhsNode.getNode());
-                    } else {
-                        String err = "Program error - result: " + result
-                            + " lhComp: " + lhComp + " rhComp: " + rhComp;
-                        throw new Error(err);
-                    }
-                }
-            }
-            return result;
-        } // compare 
-    }
-
-} // class GenericTreeNode 
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodeListOrdererFactoryI.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodeListOrdererFactoryI.java
deleted file mode 100644
index c98549829..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodeListOrdererFactoryI.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-
-/** 
- * Factory to produce orderers per children list pair.
- * Using a factory permits generation/selection of the right orderer 
- * for each set of children to be compared, potentially considering
- * the visitor expectations.  Note that while orderers may change during
- * traversals, visitors do not.
- */
-public interface GenericTreeNodeListOrdererFactoryI {
-    /** 
-     * Produce the correct orderer for the children of the given GenericTreeNodes
-     * @return GenericTreeNodeListOrdererI for children, or null if none to be used 
-     */
-    public GenericTreeNodeListOrdererI produce(GenericTreeNode lhs, GenericTreeNode rhs,
-                                               GenericTreeNodesVisitorI visitor);
-}
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodeListOrdererI.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodeListOrdererI.java
deleted file mode 100644
index 7f5e2bd07..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodeListOrdererI.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-
-import java.util.List;
-
-/**
- * Puts two lists of GenericTreeNode children
- * in traversal order for comparison purposes.
- * Given two lists, produce two lists which
- * should be the comparison order of the two.
- * In the case of set comparison, this will 
- * impose an ordering on the produced lists 
- * such that the equal elements are pairs.
- * In the case of list comparison, it may
- * impose an ordering if the comparator itself
- * does not. 
- * All Lists must contain only GenericTreeNode.
- */
-public interface GenericTreeNodeListOrdererI {
-    /**
-     * Produce lists representing the proper transformation of 
-     * the children for a given visitor.  
-     * To use the existing lists, return them in a new array.
-     * You may return null for one or both Lists. 
-     * @param lhs the List representing the left-hand-side
-     *            which contains only GenericTreeNode
-     * @param rhs the List representing the right-hand-side
-     *            which contains only GenericTreeNode
-     * @return two lists List[] (0 => lhs, 1 => rhs)
-     */
-    public List[] produceLists(List lhs, List rhs);
-}
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodesVisitorI.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodesVisitorI.java
deleted file mode 100644
index da1dcf2a5..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/GenericTreeNodesVisitorI.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-/**
- * Visit a node-pair in the trees, 
- * signalling whether to continue traversal.
- */
-public interface GenericTreeNodesVisitorI {
-    /**
-     * Visit nodes in parallel trees.
-     * One (but not both) of the input nodes may be null.
-     * @param lhs the GenericTreeNode on the left-hand-side of a binary operation
-     *            (may be null)
-     * @param lhs the GenericTreeNode on the right-hand-side of a binary operation
-     *            (may be null)
-     * @return true if should continue visiting 
-     */
-    public boolean visit(GenericTreeNode lhs, GenericTreeNode rhs);
-}
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/Regexp.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/Regexp.java
deleted file mode 100644
index c32310cd7..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/Regexp.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-
-import java.util.Vector;
-
-/** Generalize regular expression interface (to avoid binding to regexp provider)*/
-public interface Regexp {
-    /** @return the substrings matched in argument by this regular expression */
-    public Vector getGroups(String argument);
-
-    /** @return true if argument is matched by this regular expression */
-    public boolean matches(String argument);
-
-    /** 
-     * Set pattern used in this regular expression.
-     * May throw Exception if the pattern can be determined to be illegal 
-     * during initialization.
-     * @throws Exception if pattern is illegal
-     */
-    public void setPattern(String pattern) throws Exception;
-
-    /** 
-     * @return a string representaion of the pattern 
-     * (may not be legal or the input) 
-     */
-    public String getPattern() ;
-}
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFactory.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFactory.java
deleted file mode 100644
index 0c7bccc14..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFactory.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-// todo: non-distribution license?
-
-package org.aspectj.testing.compare;
-
-// currently in aspectj-external-lib/regexp
-import org.apache.regexp.RE;
-
-import java.util.Vector;
-
-
-/** Factory for our Regexp. */
-public class RegexpFactory {
-    public static Regexp makeRegexp() {
-        return new RegExpDelegate();
-    }
-}
-
-/** Implement Regexp by delegating to org.apache.regexp.RE */
-final class RegExpDelegate implements Regexp {
-    String pattern;
-    RE regexp;
-    public RegExpDelegate() { } 
-    public Vector getGroups(String arg) { 
-        String label = "getGroups(\"" + arg + "\") ";
-        D.log(label);
-        Vector result = null;
-        if ((null != arg) && (matches(arg))) {
-            int size = regexp.getParenCount();
-            D.log(label + " size " + size);
-            result = new Vector(size);
-            for (int i = 0; i < size; i++) {
-                Object item = regexp.getParen(i);
-                result.addElement(item);
-                D.log(label + i + ": " + item);
-            }
-        }
-        return result;
-    }
-    public boolean matches(String arg) {
-        return ((null != regexp) && regexp.match(arg));
-    }
-    public void setPattern(String pattern) throws Exception {
-        this.pattern = pattern;
-        regexp = new RE(this.pattern);
-        D.log("RE: " + regexp + " pattern: /" + pattern + "/");
-    }
-    public String getPattern()  {
-        return pattern;
-    }
-}
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFilter.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFilter.java
deleted file mode 100644
index 7ea6c7ecf..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFilter.java
+++ /dev/null
@@ -1,622 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-// todo: non-distribution license?
-package org.aspectj.testing.compare;
-
-import org.aspectj.testing.compare.Regexp;
-
-import java.util.*;
-import java.io.*;
-
-
-/** utility class for logging */
-class D {
-    public static boolean LOG = false;
-    public static void log(String s) { if (LOG) System.err.println("## " + s); }
-    static {
-        try {
-            LOG = (null != System.getProperty("DEBUG"));
-        } catch (Throwable t) {
-            // ignore
-        }
-    }
-}
-
-/** utility class for handling errors */
-class ErrHandler {
-    public static final ErrHandler DEFAULT = new ErrHandler();
-    public static final Action INFO = new Action("info") {
-            public void invoke(String message) { System.out.println("INFO: " + message); } };
-    public static final Action WARN = new Action("warn") {
-            public void invoke(String message) { System.err.println("WARNING: " + message); } };
-    public static final Action HALT = new Action("halt") {
-            public void invoke(String message) { throw new RuntimeException(message); } };
-    public static final Action ABORT = new Action("abort") {
-            public void invoke(String message) { throw new Error(message); } };
-    public static final Action EXIT = new Action("exit") {
-            public void invoke(String message) { System.err.println(message); System.exit(1); } };
-    abstract static class Action { 
-        protected final String name;
-        private Action(String name) {
-            this.name = name.toLowerCase().trim();
-        }
-        abstract public void invoke(String message);
-        public String toString() { return name; }
-    }
-    public static final void handleErr(String message, Throwable t) { 
-        DEFAULT.handle(message, t);
-    }
-    public static final void handleErr(String message) { 
-        DEFAULT.handle(message);
-    }
-    public static final void handleErr(String message, Action suggestion) { 
-        DEFAULT.handle(message, suggestion);
-    }
-    public void handle(String message) { handle(message, INFO); }
-    public void handle(String message, Throwable t) { 
-        String eMessage = (null == t ? "" : 
-                           t.getClass().getName() + ": " + t.getMessage());
-        handle(message + eMessage, HALT);
-    }
-    /**
-     * The default implementation just takes the suggested action
-     * @param message the String to pass to any Action
-     * @param suggestion the Action proposed by the caller
-     */
-    public void handle(String message, Action suggestion) {
-        suggestion.invoke(message);
-    }
-}
-
-/* old comments, not correct:
- * <li>test line against all registered select statements
- *   to get all the matching (replace) operations (unsupported)</li>
- * The algorithm is greedy in that if the user requests a line
- * and the default is no-output, it will read lines from the input
- * until one is matched (or EOF).
- */
-
-/**  
- * Process files in a minimal version of sed:
- * <li>read line using superclass LineNumberReader.readLine()</li>
- * <li>Preprocess with case and white space operations</li>
- * <li>run all the replace operations on the input, in order</li>
- * <li>return the line.</li>
- * Using anything but the <code>readLine()</code> method will circumvent
- * the regular expression replacement processing.
- */
-public class RegexpFilter {
-    protected static final String[] NO_STRINGS = new String[]{};
-
-    // ---------------------------------------------- static methods
-    /**
-     * Process file (or System.in) like sed.
-     * This only calls <code>RegexpFilterReader.main(args)</code>.
-     * @param args  same as for init(String[], RegexpFilter)
-     */
-    public static void main(String[] args) throws IOException {
-        RegexpFilterReader.main(args);
-    }
-
-    // todo: move String -> String[] (commas) out into utility
-    /**
-     * Initialize a RegexpFilter based on command-line style arguments
-     * in a single String. (Otherwise, same as 
-     *  <code>init(String[], RegexpFilter)</code>)
-     * The Strings are separated at , (unless \ escaped) and trimmed.
-     * Note that the escape characters are removed from before the ,.
-     * @param spec the String to break into String[]
-     * @param toSet the RegexpFilter to initialize - if null, construct one from
-     *              the file argument or stdin if there is no file argument.
-     */
-    public static RegexpFilter init(String arg, RegexpFilter toSet) {
-        if ((null == arg) || (1 > arg.length())) {
-            return init(NO_STRINGS, toSet);
-        } 
-        StringTokenizer st = new StringTokenizer(arg, ",");
-        Vector result = new Vector();
-        String last = null;
-        String next;
-        while (st.hasMoreTokens()) {
-            next = st.nextToken();
-            if (next.endsWith("\\") && (st.hasMoreTokens())) {
-                next = next.substring(0, next.length()-1);
-                last = last == null ? next : last + next;
-                continue;
-            }
-            if (null != last) {
-                next = last + next;
-                last = null;
-            }
-            result.add(next.trim());
-        }
-        String[] args = new String[result.size()];
-        result.copyInto(args);
-        return RegexpFilter.init(args, toSet);
-    }
-
-    /**
-     * Initialize a RegexpFilter based on command-line style arguments.
-     * This is the only way (currently) to set up a RegexpFilter.
-     * syntax: <code>{file | {-i|-t|-b|-s <pattern>|-s <patternFile>}..}</code>
-     * (for booleans, use lowercase to enable, uppercase to disable).
-     * @param args  the String[] containing file to input plus any number of...
-     *              <li>-i "ignore": ignore case</li>
-     *              <li>-t "trim"  : ignore leading and trailing white space</li>
-     *              <li>-b "blanks": ignore differences in all white space</li>
-     *              <li>-s "{s/pattern/expression/};...": 
-     *                      replace pattern in lines with expression</li>
-     *              <li>-S <file>  : same as s, but read commands from file</li>
-     * @param toSet the RegexpFilter to initialize - if null, construct one from
-     *              the file argument or stdin if there is no file argument.
-     */
-    public static RegexpFilter init(String[] args, RegexpFilter toSet) {
-        final String syntax = " - syntax: {file | {-i|-t|-b|-s <pattern>|-s <patternFile>}..}";
-        RegexpFilter result = (null != toSet ? toSet : new RegexpFilter());
-        if ((null != args) && (0 < args.length)) {
-            for (int i = 0; i < args.length; i++) {
-                String arg = args[i];
-                if ((null == arg) || (1 > arg.length())) continue;
-                if (arg.startsWith("-"))  {
-                    switch (arg.charAt(1)) {
-                    case 'i' : result.ignoreCase = true; break;
-                    case 'I' : result.ignoreCase = false; break;
-                    case 'b' : result.collapseWhitespace = true; break;
-                    case 'B' : result.collapseWhitespace = false; break;
-                    case 't' : result.trimWhitespace = true; break;
-                    case 'T' : result.trimWhitespace = false; break;
-                    case 's' : ++i; 
-                        if (i < args.length) {
-                            result.getOperationList().addOperation(args[i]); 
-                        } else {
-                            String err = "need arg after -s " + syntax;
-                            ErrHandler.handleErr(err, ErrHandler.WARN); 
-                        }
-                    break; 
-                    case 'S' : ++i; 
-                        if (i < args.length) {
-                            result.getOperationList().addFile(args[i]); 
-                        } else {
-                            String err = "need arg after -s " + syntax;
-                            ErrHandler.handleErr(err, ErrHandler.WARN); 
-                        }
-                    break; 
-                    default: 
-                        String err = "unrecognized flag : " + arg + syntax;
-                        ErrHandler.handleErr(err, ErrHandler.WARN); 
-                        break;
-                    }
-                } else if (null != result) {
-                    ErrHandler.handleErr("unexpected arg " + arg + syntax, ErrHandler.WARN); 
-                    break;
-                } else { // unflagged argument, need file - should be input file
-                    File _file = new File(arg);
-                    if (_file.exists() && _file.canRead()) {
-                        result.setFile(_file);
-                    }
-                }
-            } // reading args
-        }  // have args
-        return result;
-    } // init
-    
-    // ---------------------------------------------- instance fields
-    /** ignore case by converting lines to upper case */
-    protected boolean ignoreCase  = false;
-    /** collapse internal whitespace by converting to space character */
-    protected boolean collapseWhitespace  = true;
-    /** trim leading and trailing whitespace from lines before comparison */
-    protected boolean trimWhitespace  = false;
-    /** replace input per replace operations */
-    protected boolean replace  = false;
-    /** operations to process the file with */
-    protected OperationList operations;
-    /** handler for our errors*/
-    protected ErrHandler handler  = ErrHandler.DEFAULT;
-    /** the File to use */
-    protected File file = null;
-
-    // ---------------------------------------------- constructors
-    /** no getter/setters yet, so construct using 
-     * <code>static RegexpFilter init(String[],RegexpFilter)</code> 
-     */
-    protected RegexpFilter() { }
-
-    // ---------------------------------------------- instance methods
-   
-
-    /**
-     * Set a file for this RegexpFilter.
-     * This makes command-line initialization easier.
-     * @param file the File to set for this RegexpFilter
-     */
-    public void setFile(File file) { this.file = file; } 
-
-    /**
-     * Return file this RegexpFilter was initialized with.
-     * @return the File this RegexpFilter was initialized with (may be null).
-     */
-    public File getFile() { return file; } 
- 
-    /**
-     * Lazy construction of operations list
-     */
-    protected OperationList getOperationList() {
-        if (null == operations) {
-            operations = new OperationList();
-            replace = true;
-        }
-        return operations;
-    }
-
-    /**
-     * Process line, applying case and whitespace operations
-     * before delegating to replace.
-     * @param string the String to proces
-     * @return the String as processed
-     */
-    protected String process(String string) {
-        String label = "process(\"" + string + "\")";
-        D.log(label);
-        if (null == string) return null;
-        String result = string;
-        if (ignoreCase) {
-            result = result.toUpperCase();
-        }
-        if (trimWhitespace) {
-            result = result.trim();
-        }
-        if (collapseWhitespace) {
-            final StringBuffer collapse = new StringBuffer();
-            StringTokenizer tokens = new StringTokenizer(result);
-            boolean hasMoreTokens = tokens.hasMoreTokens();
-            while (hasMoreTokens) {
-                collapse.append(tokens.nextToken());
-                hasMoreTokens = tokens.hasMoreTokens();
-                if (hasMoreTokens) {
-                    collapse.append(" ");
-                }
-            }
-            result = collapse.toString();
-        }
-        if (replace) {
-            result = getOperationList().replace(result);
-            D.log(label + " result " + result);
-        }
-        return result;
-    }
-
-    /** 
-     * container for ReplaceOperations constructs on add,
-     * runs operations against input.
-     */
-    class OperationList {
-        final ArrayList list;
-        public OperationList() { 
-            list = new ArrayList();
-        }
-
-        /**
-         * Run input through all the operations in this list
-         * and return the result.
-         * @param input the String to process
-         * @return the String result of running input through all replace 
-         *         operations in order.
-         */
-        public String replace(String input) {
-            if (null == input) return null;
-            Iterator operations = operations();
-            while (operations.hasNext()) {
-                ReplaceOperation operation = (ReplaceOperation) operations.next();
-                input = operation.replace(input);
-            }
-            return input;
-        }
-
-        /**
-         * Add operations read from file, one per line,
-         * ignoring empty lines and # or // comments.
-         * ';' delimits operations within a line as it does
-         * for addOperation(String), so you must \ escape ;
-         * in the search or replace segments
-         */
-        public void addFile(String path) { 
-            if (null == path) {
-                handler.handle("null path", ErrHandler.ABORT);
-            } else {
-                File file = new File(path);
-                if (!file.exists() && file.canRead()) {
-                    handler.handle("invalid path: " + path, ErrHandler.ABORT);
-                } else {
-                    BufferedReader reader = null;
-                    int lineNumber = 0;
-                    String line  = null;
-                    try {
-                        reader = new BufferedReader(new FileReader(file));
-                        while (null != (line = reader.readLine())) {
-                            lineNumber++;
-                            int loc = line.indexOf("#");
-                            if (-1 != loc) {
-                                line = line.substring(0,loc);
-                            }
-                            loc = line.indexOf("//");
-                            if (-1 != loc) {
-                                line = line.substring(0,loc);
-                            }
-                            line = line.trim();
-                            if (1 > line.length()) continue;
-                            addOperation(line);
-                        }
-                    } catch (IOException e) {
-                        String message ="Error processing file " + path 
-                            + " at line " + lineNumber + ": \"" + line + "\""
-                            + ": " + e.getClass().getName() + ": " + e.getMessage() ;
-                        handler.handle(message, ErrHandler.ABORT);
-                    } finally {
-                        try  { 
-                            if (reader != null) reader.close();
-                        } catch (IOException e) {
-                            // ignore
-                        }
-                    }
-                }
-            }
-        }
-
-        /**
-         * Add operation to list, emitting warning and returning false if not created.
-         * Add multiple operations at once by separating with ';'
-         * (so any ; in search or replace must be escaped).
-         * @param operation a String acceptable to 
-         *                  <code>ReplaceOperation.makeReplaceOperation(String, ErrHandler)</code>,
-         *                  of the form sX{search}X{replace}X{g};..
-         * @return false if not all added.
-         */
-        public boolean addOperation(String operation) { 
-            StringTokenizer st = new StringTokenizer(operation, ";", false);
-            String last = null;
-            ReplaceOperation toAdd;
-            boolean allAdded = true;
-            while (st.hasMoreTokens()) {
-                // grab tokens, accumulating if \ escapes ; delimiter 
-                String next = st.nextToken();
-                if (next.endsWith("\\") && (st.hasMoreTokens())) {
-                    next = next.substring(0, next.length()-1);
-                    last = (last == null ? next : last + next);
-                    continue;
-                }
-                if (null != last) {
-                    next = last + next;
-                    last = null;
-                }
-                toAdd = ReplaceOperation.makeReplaceOperation(next, handler);
-                if (null != toAdd) {
-                    list.add(toAdd);
-                } else {
-                    String label = "RegexpFilter.OperationList.addOperation(\"" + operation + "\"): ";
-                    handler.handle(label + " input not accepted " , ErrHandler.WARN);
-                    if (allAdded) allAdded = false;
-                }
-            }
-            return allAdded;
-        }
-
-        /**
-         * @return an Iterator over the list of ReplaceOperation
-         */
-        public Iterator operations() {
-            return list.iterator();
-        }
-    } // class OperationList
-} // class RegexpFilter
-
-/**
- * Encapsulate a search/replace operation which uses a RegExp.
- */
-class ReplaceOperation {
-    /**
-     * This accepts a sed-like substitute command, except that
-     * the delimiter character may not be used anywhere in the 
-     * search or replace strings, even if escaped.  You may use
-     * any delimiter character.
-     * Note that although g (replace-globally) is supported as input, 
-     * it is ignored in this implementation.
-     * @param operation a String of the form sX{search}X{replace}X{g}
-     */
-    public static ReplaceOperation makeReplaceOperation(String operation, ErrHandler handler) {
-        ReplaceOperation result = null;
-        StringBuffer err = (null == handler ? null : new StringBuffer());
-        final String syntax = "sX{search}X{replace}X{g}";
-        // todo: use Point p = isValidOperation(operation);
-        if (null == operation) {
-            if (null != err) err.append("null operation");
-        } else if (5 > operation.length()) {
-            if (null != err) err.append("empty operation");
-        } else if (!operation.startsWith("s")) {
-            if (null != err) err.append("expecting s: " + syntax);
-       } else {
-            String sep = operation.substring(1,2);
-            int mid = operation.indexOf(sep, 2);
-            if (-1 == mid) {
-                if (null != handler) err.append("expecting middle \"" + sep + "\": " + syntax);
-            } else if (mid == 2) {
-                if (null != handler) err.append("expecting search before middle \"" + sep + "\": " + syntax);
-            } else {
-                int end = operation.indexOf(sep, mid+1);
-                if (-1 == end) {
-                    if (null != handler) err.append("expecting final \"" + sep + "\": " + syntax);
-                } else {
-                    String search = operation.substring(2,mid);
-                    if (!ReplaceOperation.isValidSearch(search)) {
-                        if (null != handler) err.append("invalid search \"" + search + "\": " + syntax);
-                    } else {
-                        String replace = operation.substring(mid+1,end);
-                        if (!ReplaceOperation.isValidReplace(replace)) {
-                            if (null != handler) err.append("invalid replace \"" + replace + "\": " + syntax);
-                        } else {
-                            result = new ReplaceOperation(search, replace, operation.endsWith("g"), handler);
-                        }
-                    }
-                }
-            }
-        }
-        if ((0 < err.length()) && (null != handler)) {
-            err.append(" operation=\"" + operation + "\"");
-            handler.handle(err.toString(), ErrHandler.HALT);
-        }
-        return result;
-    }
-
-    /**
-     * Return true if the input string represents a valid search operation
-     * @param replace the String representing a search expression
-     */
-    protected static boolean isValidSearch(String search) { // todo: too weak to be useful now
-        return ((null != search) && (0 < search.length()));
-    }
-
-    /**
-     * Return Point x=mid, y=end if the input string represents a valid search operation
-     * @param search the String representing a search expression
-    protected static Point isValidOperation(String search) {
-        if (null != search) {
-            final int length = search.length();
-            if (5 < length) {
-                String sep = search.substring(2,3);
-                int mid = search.indexOf(sep, 3);
-                if (3 < mid) {
-                    int end = search.indexOf(sep, mid+1);
-                    if ((end == length-1) 
-                        || ((end == length-2) 
-                            && search.endsWith("g"))) {
-                        return new Point(mid, end);
-                    }
-                }
-            }
-        }
-        return null;
-    }
-     */
-
-    /**
-     * Return true if the input string represents a valid replace operation
-     * @param replace the String representing a replace expression
-     */
-    protected static boolean isValidReplace(String replace) { // todo: too weak to be useful now
-        boolean result = (null != replace); 
-        return result;
-    } // isValidReplace
-
-    // ------------------------------------------------- instance members
-    /** If true, repeat replace as often as possible (todo: repeat not supported) */
-    protected final boolean repeat;
-    /** search pattern */
-    protected final String search;
-    /** replace pattern */
-    protected final String replace;
-    /** regexp processor */
-    protected final Regexp regexp;
-    /** replace buffer (read-only) */
-    protected final char[] replaceBuffer;
-    /** error handler */
-    protected final ErrHandler handler;
-
-    // ------------------------------------------------- constructors
-    private ReplaceOperation(String search, String replace, boolean repeat, ErrHandler handler) {
-        this.search = search; 
-        this.replace = replace; 
-        this.replaceBuffer = replace.toCharArray();
-        this.repeat = repeat; 
-        this.handler = (null != handler ? handler : ErrHandler.DEFAULT);
-        this.regexp = RegexpFactory.makeRegexp();
-        try {
-            this.regexp.setPattern(search);
-        } catch (Exception e) {
-            this.handler.handle("setting search=" + search, e);
-        }
-    }
-
-
-    /**
-     * Return true if the input would be matched by the search string of this ReplaceOperation.
-     * @param input the String to compare
-     * @return true if the input would be matched by the search string of this ReplaceOperation
-     */
-    public boolean matches(String input) {
-        return ((null != input) && regexp.matches(input));
-    } // matches
-
-    /**
-     * Replace any search text in input with replacement text, 
-     * returning input if there is no match. More specifically, 
-    * <li> emit unmatched prefix, if any</li>
-    * <li> emit replacement text as-is, except that
-    *   \[0-9] in the replacement text is replaced
-    *   with the matching subsection of the input text</li>
-    * <li> emit unmatched suffix, if any</li>
-     * @param input the String to search and replace
-     * @throws IllegalArgumentException if null == input 
-     */
-    public String replace(String input) {
-        if (null == input) throw new IllegalArgumentException("null input");
-        String label = "replace(\"" + input + "\") ";
-        D.log(label);
-        if (matches(input)) {
-            StringBuffer buffer = new StringBuffer();
-            final int length = replaceBuffer.length;
-            Vector groups = regexp.getGroups(input);
-            if ((null == groups) || (1 > groups.size())) {
-                handler.handle(label + "matched but no groups? ");
-                return input;
-            }
-            buffer.setLength(0);
-            // group 0 is whole; if not same as input, print prefix/suffix
-            String matchedPart = (String) groups.elementAt(0);
-            final int matchStart = input.indexOf(matchedPart);
-            final int matchEnd = matchStart + matchedPart.length();
-            if (0 < matchStart) {
-                buffer.append(input.substring(0, matchStart));
-            }
-            // true if \ escaping special char, esp. replace \[0-9]
-            boolean specialChar = false; 
-            for (int i = 0; i < length; i++) {
-                char c = replaceBuffer[i];
-                if (specialChar) { 
-                    int value = Character.digit(c, 10); // only 0-9 supported
-                    if ((0 <= value) && (value < groups.size())) {
-                        buffer.append((String) groups.elementAt(value));
-                    } else {
-                        buffer.append(c);
-                    }
-                    specialChar = false;
-                } else if ('\\' != c) {
-                    D.log("." + c);
-                    buffer.append(c);
-                } else {
-                    specialChar = true;
-                }
-            }
-            if (specialChar) {
-                handler.handle(label + "\\ without register: " + replace,
-                               ErrHandler.ABORT);
-            }
-            if (matchEnd < input.length()) {
-                buffer.append(input.substring(matchEnd));
-            }
-            input = buffer.toString();
-        }
-        return input;
-    } // replace
-} // class ReplaceOperation
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFilterReader.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFilterReader.java
deleted file mode 100644
index 5021a5efe..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/RegexpFilterReader.java
+++ /dev/null
@@ -1,291 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-
-package org.aspectj.testing.compare;
-
-
-import org.aspectj.testing.util.StringVisitor;
-
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintStream;
-import java.io.Reader;
-import java.util.Vector;
-
-/**
- * Adapt Writer to StringVisitor, with pre- and post-write
- * methods for subclasses to override.
- */
-class StringDumper implements StringVisitor {
-    /** subclasses should write errors here and be silent if null */
-    protected PrintStream errSink;
-    private final boolean appendNewlines;
-    private final BufferedWriter writer;
-    /** true only if writer non-null and close() was invoked */
-    private boolean closed;
-
-    /**
-     * @param writer the Writer to write to - ignored if null
-     * @param appendNewLines if true, append newlines after writing
-     */
-    public StringDumper(BufferedWriter writer, boolean appendNewlines) {
-        this.appendNewlines = appendNewlines;
-        this.writer = writer;
-        // closed = false;
-        errSink = System.err;
-    }
-
-    /**
-     * Set error sink - may be null to ignore IOExceptions.
-     * @param err the PrintStream to use for errors (silent if null)
-     */
-    public void setErrorSink(PrintStream err) {
-        errSink = err;
-    }
-
-    /**
-     * Invoked before the String is written.
-     * This implementation does nothing.
-     * @param string the String to be written
-     * @return false if writing should abort
-     */
-    protected boolean preWrite(String string) 
-        throws IOException {
-        return true;
-    }
-
-    /**
-     * Implement StringVisitor.accept(String)
-     * by doing preWrite(String), process(String),
-     * writer.write(String...), and postWrite(String),
-     * any one of which may result in a false return value.
-     * @throws Error if invoked after <code>close()</code>
-     */
-    public final boolean accept(String string) {
-        if (closed) {
-            String m = "did close() before accept(\"" + string + "\")";
-            throw new Error(m);
-        }
-        if (null == writer) return false;
-        try {
-            if (!preWrite(string)) return false;
-            string = process(string);
-            if (null == string) return false;
-            if (null != writer) writer.write(string, 0, string.length());
-            if (!postWrite(string)) return false;
-        } catch (IOException e) {
-            PrintStream sink = errSink;
-            if (null != sink) e.printStackTrace(sink);
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * Transform the input before writing.
-     * This implementation returns the input.
-     * @param string the String to transform
-     * @return the String as changed - if null,
-     *         then halt and return false from the accept method.
-     */
-    protected String process(String string) {
-        return string;
-    }
-
-    /**
-     * Invoked after the String is written.
-     * This implementation handles writing of the newline.
-     * @param string the String that was written
-     * @return false if writing should abort
-     */
-    protected boolean postWrite(String string) 
-        throws IOException {
-        if (appendNewlines && null != writer) {
-            writer.newLine();
-        }
-        return true;
-    }
-
-    /** convenience method to close adopted writer */
-    public void close() throws IOException {
-        if (null != writer) {
-            writer.close();
-            closed = true;
-        }
-    }
-}
-class FilteredDumper extends StringDumper {
-    protected final RegexpFilter filter;
-    public FilteredDumper(BufferedWriter writer, 
-                          boolean appendNewlines,
-                          RegexpFilter filter) {
-        super(writer, appendNewlines);
-        this.filter = filter;
-    }
-    public String process(String arg) {
-        return filter.process(arg);
-    }
-}
-
-class FilteredAccumulator extends FilteredDumper {
-    protected final Vector results;
-    public FilteredAccumulator(RegexpFilter filter) {
-        super(null, false, filter);
-        results = new Vector();
-    }
-    public String process(String arg) {
-        arg = super.process(arg);
-        synchronized (results) {
-            results.add(arg);
-        }
-        return arg;
-    }
-    public Vector getResults() {
-        synchronized (results) {
-            return (Vector) results.clone();
-        }
-    }
-}
-
-/**  
-
-/**  
- * Input file, using a RegexpFilter to preprocess each line.
- * <li>read line using superclass LineNumberReader.readLine()</li>
- * <li>Preprocess with case and white space operations</li>
- * <li>run all the replace operations on the input, in order</li>
- * <li>return the line.</li>
- * Using anything but the <code>readLine()</code> method will circumvent
- * the regular expression replacement processing.
- */
-public class RegexpFilterReader extends BufferedReader {
-
-    // ---------------------------------------------- static methods
-
-    /**
-     * Pass lines from BufferedReader to visitor.
-     * Stop reading lines if visitor returns false.
-     * @param input the BufferedReader with the input 
-     *              - if null, use System.in
-     * @param visitor the StringVisitor to pass each line 
-     *                if null, just read in all lines and ignore
-     */
-    public static void visitLines(BufferedReader input, 
-                                  StringVisitor visitor) 
-        throws IOException {
-        final boolean openInput = (null == input);
-        if (openInput) input = new BufferedReader(new InputStreamReader(System.in));
-        try {
-            String line = null;
-            if (null == visitor) { 
-                while (null != (line = input.readLine())) { 
-                    // read and ignore
-                }
-            } else {
-                while (null != (line = input.readLine())) { 
-                    if (!visitor.accept(line)) {
-                        break;
-                    }
-                }
-            }
-        } finally {
-            if (openInput && (null != input)) {
-                try { input.close(); }  // todo: ok to close since System.in underlies?
-                catch (IOException e) {
-                    e.printStackTrace(System.err);
-                }
-            }
-        }
-    } // visitLines
-
-    // todo move write(in,out) to a utility class
-    /**
-     * Convenience method to write one file to another by line.
-     * Neither input nor output are closed.
-     * @param input the BufferedReader with the input - if null, use System.in
-     * @param output the BufferedWriter for the output - if null, use System.out
-     */
-    public static void write(BufferedReader input, 
-                             BufferedWriter output)  
-        throws IOException {
-        final boolean openOutput = (null == output);
-        if (openOutput) output = new BufferedWriter(new OutputStreamWriter(System.out));
-        StringDumper visitor = new StringDumper(output, true);
-        try {
-            RegexpFilterReader.visitLines(input, visitor);
-        } finally {
-            if (openOutput && (null != visitor)) {
-                try { visitor.close(); }  // todo: ok to close since System.out underlies?
-                catch (IOException e) {
-                    e.printStackTrace(System.err);
-                }
-            }
-        }
-    } // write
-
-    /**
-     * Process file (or System.in) like sed.
-     * @param args  the String[] containing RegexpFilter arguments
-     */
-    public static void main(String[] args) throws IOException {
-        RegexpFilter filter = RegexpFilter.init(args, null);
-        if (null != filter) {
-            File file = filter.getFile();
-            Reader reader = null;
-            if (file != null) {
-                reader = new FileReader(file);
-            } else {
-                reader = new InputStreamReader(System.in);
-            }
-            RegexpFilterReader me = new RegexpFilterReader(reader);
-            me.setFilter(filter);
-            RegexpFilterReader.write(me, null);
-        }
-    }
-
-    // ---------------------------------------------- constructors
-    public RegexpFilterReader(Reader reader) {
-        super(reader);
-    }
-    public RegexpFilterReader(Reader reader, int size) {
-        super(reader, size);
-    }
-
-    // ---------------------------------------------- instance fields
-    protected RegexpFilter filter;
-    // ---------------------------------------------- instance methods
-    public void setFilter(RegexpFilter filter) {
-        this.filter = filter;
-    }
-   
-    /**
-     * Process each line as it is read in by the superclass.
-     */
-    public String readLine() throws IOException {
-        RegexpFilter filter = this.filter;
-        String line =  super.readLine();
-        if (null != filter) {
-            line = filter.process(line);
-        }
-        return line;
-    }
-
-} // class RegexpFilterReader
-
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/TreeCompare.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/TreeCompare.java
deleted file mode 100644
index cbf92daf5..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/TreeCompare.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-import org.aspectj.testing.compare.adapters.StructureGenericTreeNodeFactory;
-import org.aspectj.testing.compare.adapters.JTreeNodeGenericTreeNodeFactory;
-import org.aspectj.testing.compare.adapters.GenericTreeNodeFactoryI;
-// target
-// XXX compiler import org.aspectj.asm.StructureNode;
-// testing
-import javax.swing.tree.TreeNode;
-import javax.swing.tree.DefaultMutableTreeNode;
-// utils
-import java.io.*;
-
-/**
- * Compare two generic trees for tree-equality.
- * Currently does not indicate where or how they failed.
- * Input trees are serialized to disk in a format that
- * is (or can be wrapped using) <code>GenericTreeNode</code>.
- * requires files expected.ser and actual.ser
- * to deserialize to type StructureNode (untested - use Structure)
- * or Swing TreeNode.
- */
-public class TreeCompare {
-    public static boolean DODIFF;
-	/**
-	 * @param args ignored - reading expected.ser and actual.ser
-	 */
-    public static void main(String[] args) {
-        TreeCompare me = new TreeCompare();
-        File expected = new File("expected.ser");
-        File actual = new File("actual.ser");
-        if ((args.length > 0)
-            || (!expected.exists() || (!actual.exists()))) {
-            DODIFF = (args.length > 1);
-            takeSnapshot(expected);
-            takeSnapshot(actual);
-        }
-        me.compareSnapshots(expected, actual);
-    }
-    private static void takeSnapshot(File file) {
-        DefaultMutableTreeNode snapshot = getRoot(file) ;
-        ObjectOutputStream p = null;
-        FileOutputStream ostream = null;
-        try {
-            ostream = new FileOutputStream(file);
-            p = new ObjectOutputStream(ostream);
-            p.writeObject(snapshot);
-        } catch (IOException e) {
-            e.printStackTrace(System.err);
-        } finally {
-            try {
-                if (null != p) p.flush();
-                if (null != ostream) ostream.close();
-            } catch (IOException o) {} // ignored
-        }
-    }
-
-    private static DefaultMutableTreeNode getRoot(File file) {
-        boolean isActual = (!DODIFF ? false : (-1 != (file.getPath().indexOf("actual"))));
-        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Edna");
-        DefaultMutableTreeNode child = new DefaultMutableTreeNode("Evalyn");
-        root.add(child);
-        child.add(new DefaultMutableTreeNode("Marsha"));
-        child.add(new DefaultMutableTreeNode("Ray"));
-        if (DODIFF && isActual) { // Bill added to actual
-            child.add(new DefaultMutableTreeNode("Bill"));
-        }
-        child = new DefaultMutableTreeNode("Clifford");
-        root.add(child);
-        child.add(new DefaultMutableTreeNode("Terry"));
-        if (DODIFF && isActual) { // Peter mispelled in actual
-            child.add(new DefaultMutableTreeNode("peter"));
-        } else {
-            child.add(new DefaultMutableTreeNode("Peter"));
-        }
-        child.add(new DefaultMutableTreeNode("Mary"));
-        child = new DefaultMutableTreeNode("Anastasia");
-        root.add(child);
-        child.add(new DefaultMutableTreeNode("Victor"));
-        child.add(new DefaultMutableTreeNode("Valerie"));
-        child.add(new DefaultMutableTreeNode("Valentine"));
-        if (DODIFF && isActual) { // Vim added in actual, with a child
-            DefaultMutableTreeNode par = new DefaultMutableTreeNode("VimAdded");
-            par.add(new DefaultMutableTreeNode("Vim kid"));
-            child.add(par);
-        }
-        return root;
-    }
-
-    /**
-     * Compare two File by reading in as serialized
-     * and selecting the appropriate wrappers for the resulting
-     * Object.
-     */
-    public void compareSnapshots(File expected, File actual) {
-        try {
-            // construct the respective trees
-            FileInputStream efStream = new FileInputStream(expected);
-            ObjectInputStream eStream  = new ObjectInputStream(efStream);
-            FileInputStream afStream = new FileInputStream(actual);
-            ObjectInputStream aStream  = new ObjectInputStream(afStream);
-            Object expectedObject = eStream.readObject();
-            Object actualObject = aStream.readObject();
-            Class expectedObjectClass = (null == expectedObject ? null : expectedObject.getClass());
-            Class actualObjectClass = (null == actualObject ? null : actualObject.getClass());
-            // todo yuck: switch by type using known factories
-// XXX compiler
-//            if (StructureNode.class.isAssignableFrom(expectedObjectClass)) {
-//				if (StructureNode.class.isAssignableFrom(actualObjectClass)) {
-//                    compareSnapshots((StructureNode) expectedObject,(StructureNode) actualObject);
-//                    System.err.println("ok");
-//                } else {
-//                    signalDifferentTypes(expectedObject, actualObject);
-//                }
-//            } else if (DefaultMutableTreeNode.class.isAssignableFrom(expectedObjectClass)) {
-//				if (DefaultMutableTreeNode.class.isAssignableFrom(actualObjectClass)) {
-//                    compareSnapshots((DefaultMutableTreeNode) expectedObject,
-//									 (DefaultMutableTreeNode) actualObject);
-//                } else {
-//                    signalDifferentTypes(expectedObject, actualObject);
-//                }
-//            } else {
-                System.err.println("Unrecognized objects - expected: "
-                                   + expectedObject + " actual: " + actualObject);
-//            }
-        } catch (Throwable t) {
-            System.err.println("TEST FAILED: " + t.getMessage());
-            t.printStackTrace(System.err);
-            return;
-        }
-    } // compareSnapshots(File, File)
-
-    public void signalDifferentTypes(Object lhs, Object rhs) {
-        Class lhc = lhs.getClass();
-        Class rhc = rhs.getClass();
-        String err = "Different Types? lhs: " + lhc + "=" + lhs
-            + " rhs: " + rhc + "=" + rhs;
-        throw new Error(err);
-    }
-
-    /**
-     * Compare two StructureNode by wrapping in GenericTreeNode
-     */
-// XXX compiler
-//    public void compareSnapshots(StructureNode expected, StructureNode actual) {
-//        try {
-//            GenericTreeNodeFactoryI factory =
-//                StructureGenericTreeNodeFactory.SINGLETON;
-//            // this is the custom part: adapter generating generic model
-//            GenericTreeNode expectRoot
-//                = factory.createGenericTreeNode(expected, null);
-//            GenericTreeNode actualRoot
-//                = factory.createGenericTreeNode(actual, null);
-//            if (null == actualRoot) System.err.println("null actualRoot");
-//            if (null == expectRoot) System.err.println("null expectRoot");
-//            compareSnapshots(expectRoot, actualRoot);
-//        } catch (Throwable t) {
-//            System.err.println("TEST FAILED: " + t.getMessage());
-//            t.printStackTrace(System.err);
-//            return;
-//        }
-//    } // compareSnapshots(TreeModel, TreeModel)
-
-    /**
-     * Compare two Swing TreeModel by wrapping in GenericTreeNode
-     */
-    public void compareSnapshots(TreeNode expected, TreeNode actual) {
-        try {
-            GenericTreeNodeFactoryI factory =
-                JTreeNodeGenericTreeNodeFactory.SINGLETON;
-            // this is the custom part: adapter generating generic model
-            GenericTreeNode expectRoot
-                = factory.createGenericTreeNode(expected, null);
-            GenericTreeNode actualRoot
-                = factory.createGenericTreeNode(actual, null);
-            if (null == actualRoot) System.err.println("null actualRoot");
-            if (null == expectRoot) System.err.println("null expectRoot");
-            compareSnapshots(expectRoot, actualRoot);
-        } catch (Throwable t) {
-            System.err.println("TEST FAILED: " + t.getMessage());
-            t.printStackTrace(System.err);
-            return;
-        }
-    } // compareSnapshots(TreeModel, TreeModel)
-
-    /** Compare GenericTreeNode trees exactly, printing errors */
-    public void compareSnapshots(GenericTreeNode expected, GenericTreeNode actual) {
-        try {
-            //GenericTreeNodesVisitorI visitor = GenericTreeNode.PRINTALL;
-            GenericTreeNodesVisitorI visitor = GenericTreeNode.PRINTERR;
-            //GenericTreeNodesVisitorI visitor = GenericTreeNode.EXACT;
-
-            if (GenericTreeNode.traverse(expected, actual, null, visitor)) {
-                System.err.println("TEST PASSED");
-            } else {
-                System.err.println("TEST FAILED");
-            }
-        } catch (Throwable t) {
-            System.err.println("TEST FAILED: " + t.getMessage());
-            t.printStackTrace(System.err);
-            return;
-        }
-    } // compareSnapshots(GenericTreeNode, GenericTreeNode)
-} // TreeCompare
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/GenericTreeNodeFactoryI.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/GenericTreeNodeFactoryI.java
deleted file mode 100644
index adee3d3ee..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/GenericTreeNodeFactoryI.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare.adapters;
-
-import org.aspectj.testing.compare.GenericTreeNode;
-/**
- * Encapsulate the implementation of an factory to create
- * a GenericTreeNode tree from a given input type, to permit
- * a general, pluggable factory to operate based on source type.
- */
-public interface GenericTreeNodeFactoryI {
-    /** @return the expected Class of the root node supported by this factory */
-    public Class getRootClass();
-
-    /**
-     * Create a wrapped generic tree with the input root tree as delegates.
-     * @param root the {rootClass} root of the tree to convert - never null
-     * @throws IllegalArgumentException if root is null or not assignable to rootClass
-     */
-    public GenericTreeNode createGenericTreeNode(Object root, GenericTreeNode parent);
-}
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/JTreeNodeGenericTreeNodeFactory.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/JTreeNodeGenericTreeNodeFactory.java
deleted file mode 100644
index 5f48eef40..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/JTreeNodeGenericTreeNodeFactory.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare.adapters;
-
-import org.aspectj.testing.compare.GenericTreeNode;
-import org.aspectj.testing.compare.*;
-
-import javax.swing.tree.*; // sample uses TreeModel...
-import java.util.*; 
-
-/**
- * Factory for adapting Swing TreeNode to GenericTreeNode
- */
-public class JTreeNodeGenericTreeNodeFactory implements GenericTreeNodeFactoryI {
-    public static final GenericTreeNodeFactoryI SINGLETON
-        = new JTreeNodeGenericTreeNodeFactory();
-    private JTreeNodeGenericTreeNodeFactory() {}
-    public Class getRootClass() {
-        return TreeNode.class;
-    }
-
-    /** 
-     * Adapt swing TreeModel to tree rooted at GenericTreeNode 
-     * Only takes the current state of a TreeModel which does not
-     * change during the construction of the adapter. If the
-     * TreeModel changes, you can ask the adapter for a newly
-     * wrapped tree.
-     * Recursively convert entire tree from root to a wrapped tree
-     * Note this takes a snapshot of the tree such that changes to
-     * the TreeModel after the constructor returns are ignored.
-     * Changes during the constructor produce undetermined results.
-     * @param root the TreeNode taken as root of a tree to wrap
-     * @param parent the parent of the resulting GenericTreeNode
-     * @throws IllegalArgumentException if root is null 
-     *         or if children are not instanceof TreeNode.
-     */
-    public GenericTreeNode createGenericTreeNode(Object root, GenericTreeNode parent) {
-        if (null == root) {
-            throw new IllegalArgumentException("null root");
-        }
-        if (! (root instanceof TreeNode)) {
-            throw new IllegalArgumentException("not TreeNode: " + root);
-        }
-        TreeNode rootNode = (TreeNode) root;
-        final int numKids = rootNode.getChildCount();
-        ArrayList kids = new ArrayList(numKids);
-        Enumeration children = rootNode.children();
-        Object child;
-        GenericTreeNode result = new GenericTreeNode();
-        for (int i = 0; i < numKids; i++) {
-            if (! children.hasMoreElements()) {
-                throw new Error("(! children.hasNext())");
-            } 
-            child = children.nextElement();
-            if (! (child instanceof TreeNode)) {
-                throw new Error("! (child instanceof TreeNode)): " + child );
-            }
-            kids.add(createGenericTreeNode((TreeNode) child, result));
-        }
-        //result.init(parent, GenericTreeNode.COMPARATOR, rootNode, kids, null);
-        result.init(parent, JTreeNodeComparator.SINGLETON, rootNode, kids, null);
-        return result;
-    } 
-
-    /** Comparator for swing TreeNode todo convert from TreeNode to DefaultMutableTreeNode */
-    static class JTreeNodeComparator implements Comparator {
-        public static Comparator SINGLETON = new JTreeNodeComparator();
-        private JTreeNodeComparator () {}
-        public int compare(Object lhs, Object rhs) {
-            int result = CompareUtil.compare(lhs, rhs);
-            if (Integer.MAX_VALUE == result) {
-                Class lhClass = lhs.getClass() ;
-                Class rhClass = rhs.getClass() ;
-                if ((DefaultMutableTreeNode.class.isAssignableFrom(lhClass)) 
-                    && (DefaultMutableTreeNode.class.isAssignableFrom(rhClass))) {
-                    DefaultMutableTreeNode lh = (DefaultMutableTreeNode) lhs ;
-                    DefaultMutableTreeNode rh = (DefaultMutableTreeNode) rhs ;
-                    Object lhObject = lh.getUserObject();
-                    Object rhObject = rh.getUserObject();
-                    result = CompareUtil.compare(lhs, rhs);
-                    if (Integer.MAX_VALUE == result) {
-                        result = lhObject.toString().compareTo(rhObject.toString());
-                    }
-                } else { // urk - broken unless wrapper
-                    result = lhs.toString().compareTo(rhs.toString());
-                }
-            }
-            return result;
-        }
-    }
-}
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/Structure.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/Structure.java
deleted file mode 100644
index b669f7c6b..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/Structure.java
+++ /dev/null
@@ -1,438 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare.adapters;
-
-import org.aspectj.testing.compare.GenericTreeNode;
-import org.aspectj.testing.compare.GenericTreeNodesVisitorI;
-import org.aspectj.testing.compare.GenericTreeNodeListOrdererFactoryI;
-import org.aspectj.testing.compare.GenericTreeNodeListOrdererI;
-import org.aspectj.testing.compare.adapters.StructureGenericTreeNodeFactory;
-
-// XXX compiler import org.aspectj.asm.StructureNode;
-// XXX wes move to ajde tests import org.aspectj.tools.ajde.StructureUtilities;
-
-import java.util.*;
-import java.io.*;
-
-/**
- * Compare or print (serialized) structure tree/graph(s).
- * Mostly thread-safe, except that (todo for now) PRINT_SINK is a mutable static
- * variable settable by the arguments.
- * See {@link #main(String[]) main} for usage.
- */
-public class Structure {
-    // ---------------------------------- static fields
-    // PRINT_SINK as static permits static inner class singleton visitors to reflect output sink policy
-    /** WARNING: print sink changeable at runtime (affects all instances of class!) */
-    public static PrintStream PRINT_SINK = System.err;
-
-    /** singleton factory to sort by string */
-    protected static final GenericTreeNodeListOrdererFactoryI STRING_SORTER_FACTORY
-        = new StringSortFactory();
-    /** singleton factory to sort by string */
-    protected static final GenericTreeNodeListOrdererI STRING_SORTER
-        = new StringSort();
-    /** singleton to sort by string */
-    protected static final Comparator STRING_COMP = new StringComparator();
-    /** default visitor printer expects only one of pair and render each parent as tab */
-    protected static final GenericTreeNodesVisitorI PRINT_EACH = new PrintEach();
-    /** visitor printer prints long version of both input (todo: not redirected by toOut) */
-    protected static final GenericTreeNodesVisitorI PRINT_ALL = GenericTreeNode.PRINTALL;
-    /** visitor printer prints long version of both input if non-matching (todo: not redirected by toOut) */
-    protected static final GenericTreeNodesVisitorI PRINT_ERR = GenericTreeNode.PRINTERR;
-    /** parms: default list of files used if no files given */
-    public static final String DEFAULT_LST = "default.lst";
-    /** parms: default argument list if none given */
-    public static final String[] DEFAULT_ARGS = new String[]
-    { "-d" , "classes" , "-workingdir", "ajworkingdir", "-argfile", DEFAULT_LST};
-
-    // ---------------------------------- static methods
-    /**
-     * Print and/or compare Structure trees.
-     * One (actual) can be compiled at the same time;
-     * either (expected or actual) may be read in from a serialized tree.
-     * Supported arguments:
-     * <table>
-     * <tr><td>{ajc compiler args}</td>
-     *     <td>The set of compiler arguments, to compile a new tree</td></tr>
-     * <tr><td>-expect {file}.ser</td>
-     *     <td>The old Structure tree to read in and compare with new</td></tr>
-     * <tr><td>-actual {file}.ser</td>
-     *     <td>The new Structure tree to read in (i.e., no compile)</td></tr>
-     * <tr><td>-save {file}.ser</td>
-     *     <td>Serialize the results of the compile to {file}.ser.</td></tr>
-     * <tr><td>-printall</td>
-     *     <td>Print all pairs in long format</td></tr>
-     * <tr><td>-printeach</td>
-     *     <td>Print each item in short format
-     *         - used when only one tree is available</td></tr>
-     * <tr><td>-printerr</td>
-     *     <td>Print pairs of items that do not match
-     *         - used when only both trees are available</td></tr>
-     * <tr><td>-sortString</td>
-     *     <td>before comparing, do a string-sort on each child list.</td></tr>
-     * <tr><td>-toOut</td>
-     *     <td>Redirect output from System.err to System.out (for all instances of this class)</td></tr>
-     * <tr><td>-notest</td>
-     *     <td>Do not run test (e.g., just compile and save)</td></tr>
-     * </table>
-     * @param args the String[] of arguments for this test - defaults supplied if empty.
-     */
-    public static void main(String[] args) {
-        new Structure().runTest(args);
-    }
-
-    // ---------------------------------- static util
-    protected static final void log(String s) {
-        final PrintStream sink = PRINT_SINK;
-        if ((null != s) &&  (null != sink)) {
-            sink.println("Structure: " + s);
-        }
-    }
-
-    protected static void signal(String message) {
-        log(message);
-    }
-    protected static void signal(String context, String event) {
-        log(context + ": " + event);
-    }
-    protected static void signal(String context, Throwable event) {
-        if (null == event) {
-            log(context);
-        } else {
-            String msg = event.getMessage();
-            log(context + ": " + msg);
-            event.printStackTrace(PRINT_SINK);
-        }
-    }
-
-    // ---------------------------------- instance fields
-    /** args result: path to serialize actual tree to */
-    protected String actualSavePath = null;
-    /** args result: path of actual serialized tree */
-    protected String actualPath = null;
-    /** args result: path of expected serialized tree */
-    protected String expectedPath = null;
-    /** args result: false if not running comparisons */
-    protected boolean doComparison = true;
-
-    /** visitor to run - print or test (default is PRINT_ALL) */
-    protected GenericTreeNodesVisitorI visitor = PRINT_ALL;
-    /** this determines for each set of children whether/how to sort them */
-    protected GenericTreeNodeListOrdererFactoryI sorter = null;
-
-    // ---------------------------------- instance methods
-    /** no-arg (default) constructor */
-    public Structure() { }
-
-    /**
-     * Clear settings before running.
-     * Use this unless you want to inherit settings from
-     * a prior run.  You can specify new arguments that
-     * overwrite the old settings.
-     * @param args the String[] used for runTest(String[])
-     * @see #clear()
-     * @see #runTest(String[])
-     */
-    public synchronized void clearAndRunTest(String[] args) {
-        actualSavePath = null;
-        actualPath = null;
-        expectedPath = null;
-        doComparison = true;
-        visitor = PRINT_ALL;
-        runTest(args);
-    }
-
-    /**
-     * Read and/or write and/or compare structure trees.
-     * Any results are delivered by the comparison visitors.
-     * The test process is as follows:
-     * <li>processArgs(..)</li>
-     * <li>saveActual(..) if saving actual to file</li>
-     * <li>doComparison(..) of actual and expected per visitor/sorter options</li>
-     * <p>If you run this consecutively, you'll inherit the values
-     * of the last run that you do not overwrite
-     * unless you invoke {@link #clear()}.  The method synchronization
-     * will not prevent another thread from interrupting your
-     * @param args the String[] defined by <code>main(String[] args)</code>
-     */
-    public synchronized void runTest(String[] args) {
-        if (null == args) throw new IllegalArgumentException("null args");
-        args = processArgs(args);
-        if (null == args) throw new IllegalArgumentException("bad args");
-// XXX compiler 
-////        StructureNode lhsRoot = loadStructureNode(expectedPath);
-////        StructureNode rhsRoot = loadStructureNode(actualPath);
-////        if (null == rhsRoot) { // not serialized - try compile
-////            // XXX wes move to ajde tests rhsRoot = StructureUtilities.buildStructureModel(args);
-////        }
-////        // save actual, if requested
-////        saveActual(rhsRoot);
-////        // do comparison (i.e., run test)
-////        doComparison(lhsRoot, rhsRoot);
-    }
-
-   /**
-     * Process arguments by extracting our arguments from callee arguments
-     * and initializing the class accordingly.
-     * {@link See main(String[])} for a list of valid arguments.
-     * @param args the String[] adopted, elements shifted down to remove ours
-     * @return a String[] containing args not relevant to us (i.e., for callee = compiler)
-     */
-    protected String[] processArgs(String[] args) {
-        if ((null == args) || (1 > args.length)) {
-            return processArgs(DEFAULT_ARGS);
-        }
-        int numFiles = 0;
-        int numArgFiles = 0;
-        final String SKIP = "skip";
-        String calleeArg;
-        int readIndex = 0;
-        int writeIndex = 0;
-        while (readIndex < args.length) {
-            final String arg = args[readIndex];
-            calleeArg = arg;
-            // assume valid arg for callee unless shown to be ours
-            if ((null == arg) || (0 == arg.length())) {
-                signal("processArgs", "empty arg at index "+ readIndex);
-                break;
-            } else if (arg.startsWith("@") || "-argfile".equals(arg)) {
-                numArgFiles++;
-            } else if (arg.endsWith(".java")) {
-                numFiles++;
-            } else if (arg.startsWith("-")) {
-                calleeArg = SKIP; // assume args are ours unless found otherwise
-                if ("-toOut".equals(arg)) {
-                    Structure.PRINT_SINK = System.out;
-                } else if ("-notest".equals(arg)) {
-                    doComparison = false;
-                } else if ("-printall".equals(arg)) {
-                    visitor = PRINT_ALL;
-                } else if ("-printeach".equals(arg)) {
-                    visitor = PRINT_EACH;
-                } else if ("-printerr".equals(arg)) {
-                    visitor = PRINT_ERR;
-                } else if ("-sortString".equals(arg)) {
-                    sorter = STRING_SORTER_FACTORY;
-                } else {  // the rest of ours require a parm
-                    readIndex++;
-                    String next = ((readIndex < args.length)
-                                   ? args[readIndex] : null);
-                    boolean nextIsOption
-                        = ((null != next) && next.startsWith("-"));
-                    if ("-expect".equals(arg)) {
-                        expectedPath = next;
-                    } else if ("-actual".equals(arg)) {
-                        actualPath = next;
-                    } else if ("-save".equals(arg)) {
-                        actualSavePath = next;
-                    } else {
-                        readIndex--;
-                        calleeArg = arg; // ok, not ours - save
-                    }
-                    if ((calleeArg == SKIP)
-                        && ((null == next) || (nextIsOption))) {
-                        signal("processArgs", arg + " requires a parameter");
-                        break;
-                    }
-                }
-            }
-            if (SKIP != calleeArg) {
-                args[writeIndex++] = calleeArg;
-            }
-            readIndex++;
-        }  // end of reading args[]
-        if (readIndex < args.length) { // bad args[] - abort (see signals above)
-            return null;
-        }
-        // if no input specified, supply default list file
-        if ((0 == numFiles) && (0 == numArgFiles) && (null == actualPath)) {
-            if (writeIndex+3 > args.length) {
-                String[] result = new String[writeIndex+2];
-                System.arraycopy(args, 0, result, 0, writeIndex);
-                args = result;
-            }
-            args[writeIndex++] = "-argfile";
-            args[writeIndex++] = DEFAULT_LST;
-        }
-        // if some args clipped (ours), clip array to actual (callee)
-        if (writeIndex < args.length) {
-            String[] result = new String[writeIndex];
-            System.arraycopy(args, 0, result, 0, writeIndex);
-            args = result;
-        }
-        return args;
-    } // processArgs(String[])
-
-// XXX compiler
-//    /**
-//     * Load any StructureNode tree at path, if possible
-//     * @param path the String path to a serialized StructureNode
-//     */
-//    protected StructureNode loadStructureNode(String path) {
-//        if (null == path) return null;
-//        StructureNode result = null;
-//        try {
-//            FileInputStream stream = new FileInputStream(path);
-//            ObjectInputStream ois  = new ObjectInputStream(stream);
-//            Object o = ois.readObject();
-//            Class oClass = (null == o ? null : o.getClass());
-//            if (StructureNode.class.isAssignableFrom(oClass)) {
-//                result = (StructureNode) o;
-//            } else {
-//                signal("loadStructureNode(\"" + path
-//                       + "\") - wrong type: " + oClass);
-//            }
-//        } catch (Throwable t) {
-//            signal("loadStructureNode(\"" + path + "\")", t);
-//        }
-//        return result;
-//     }
-//
-//    /**
-//     * Save any StructureNode tree to actualSavePath, if possible
-//     * @param actual the StructureNode root of the actual tree to save
-//     *        (ignored if null)
-//     */
-//    protected void saveActual(StructureNode actual) {
-//        if ((null != actual) && (null != actualSavePath)) {
-//            ObjectOutputStream p = null;
-//            FileOutputStream ostream = null;
-//            try {
-//                ostream = new FileOutputStream(actualSavePath);
-//                p = new ObjectOutputStream(ostream);
-//                p.writeObject(actual);
-//            } catch (Throwable e) {
-//                signal("saveActual(\"" + actual + "\") -> "
-//                       + actualSavePath, e);
-//            } finally {
-//                try {
-//                    if (null != p) p.flush();
-//                    if (null != ostream) ostream.close();
-//                } catch (IOException o) {} // ignored
-//            }
-//        }
-//    }
-
-    /**
-     * Compare two trees based on the settings for
-     * the visitor and sorter.  All results should be
-     * delivered by the visitor.
-     * @param expected the StructureNode actual tree to compare
-     * @param actual the StructureNode actual tree to compare
-     */
-    // XXX compiler
-//    protected void doComparison(StructureNode expected, StructureNode actual) {
-//        if (doComparison) {
-//            final GenericTreeNodeFactoryI fact =
-//                StructureGenericTreeNodeFactory.SINGLETON;
-//            GenericTreeNode lhs = null;
-//            if (expected != null) {
-//                lhs = fact.createGenericTreeNode(expected, null);
-//            }
-//            GenericTreeNode rhs = null;
-//            if (actual != null) {
-//                rhs = fact.createGenericTreeNode(actual, null);
-//            }
-//            GenericTreeNode.traverse(lhs, rhs, sorter, visitor);
-//        }
-//    }
-
-    /**
-     * A visitor which prints each to the sink (if any).
-     * If only one of the pair is not null,
-     * render it using GenericTreeNode.shortString()
-     */
-    static class PrintEach implements GenericTreeNodesVisitorI {
-        private PrintEach() {}
-        public boolean visit(GenericTreeNode lhs,GenericTreeNode rhs) {
-            PrintStream sink = PRINT_SINK;
-            if (null != sink) {
-                if ((lhs != null) && (rhs != null)) { // both
-                    sink.println("[lhs=" + lhs + "] [rhs=" + rhs + "]");
-                } else {
-                    GenericTreeNode gtn = (null == lhs ? rhs : lhs);
-                    if (null != gtn) {                // one
-                        sink.println(gtn.shortString());
-                    }
-                }
-            }
-            return true;
-        }
-    }  // class PrintEach
-
-    static class StringSortFactory implements GenericTreeNodeListOrdererFactoryI {
-        /**
-         * Produce the correct orderer for the children of the given GenericTreeNodes
-         * This always produces the same StringSorter.
-         * @return GenericTreeNodeListOrdererI for children, or null if none to be used
-         */
-        public GenericTreeNodeListOrdererI produce(GenericTreeNode lhs, GenericTreeNode rhs,
-                                                   GenericTreeNodesVisitorI visitor) {
-            return STRING_SORTER;
-        }
-    } // class StringSortFactory
-
-    /**
-     * sort input lists by Comparator <code>Structure.STRING_COMP</code>.
-     */
-    static class StringSort implements GenericTreeNodeListOrdererI {
-        /**
-         * Order input lists (not copies)
-         * using the Comparator <code>Structure.STRING_COMP</code>.
-         * @param lhs the List representing the left-hand-side
-         *            which contains only GenericTreeNode
-         * @param rhs the List representing the right-hand-side
-         *            which contains only GenericTreeNode
-         * @return two lists List[] (0 => lhs, 1 => rhs)
-         */
-        public List[] produceLists(List lhs, List rhs) {
-            if (null != lhs) Collections.sort(lhs, STRING_COMP);
-            if (null != rhs) Collections.sort(rhs, STRING_COMP);
-            List[] result = new List[2];
-            result[0] = lhs;
-            result[1] = rhs;
-            return result;
-        }
-    } // class CompSort
-
-    /**
-     * Comparator that imposes case-sensitive String order
-     * based on GenericTreeNode.shortString() if both are
-     * GenericTreeNode, or toString() otherwise.
-     * If both are null, considered equal.
-     * If one is null, the other is considered larger.
-     */
-    static class StringComparator implements Comparator {
-        public int compare(Object lhs, Object rhs) {
-            if (null == lhs) {
-                return (null == rhs ? 0 : -1);
-            } else if (null == rhs) {
-                return 1;
-            } else if ((lhs instanceof GenericTreeNode)
-                       && (rhs instanceof GenericTreeNode)) {
-                String lhsString = ((GenericTreeNode) lhs).shortString();
-                String rhsString = ((GenericTreeNode) rhs).shortString();
-                if (null == lhsString) {
-                    return (null == rhsString ? 0 : rhsString.compareTo(lhsString));
-                } else {
-                    return lhsString.compareTo(rhsString);
-                }
-            } else {
-                return lhs.toString().compareTo(rhs.toString());
-            }
-        }
-    } // class StringComparator
-} // class Structure
-
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/StructureGenericTreeNodeFactory.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/StructureGenericTreeNodeFactory.java
deleted file mode 100644
index 1f5883d2c..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/StructureGenericTreeNodeFactory.java
+++ /dev/null
@@ -1,308 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare.adapters;
-//
-//import org.aspectj.asm.SourceLocation;
-import org.aspectj.testing.compare.GenericTreeNode;
-//import org.aspectj.testing.compare.*;
-//import org.aspectj.asm.StructureNode;
-//import org.aspectj.asm.LinkNode;
-//import org.aspectj.asm.RelationNode;
-//import org.aspectj.asm.Relation;
-//import org.aspectj.asm.ProgramElementNode;
-//import java.util.*;
-//
-///**
-// * Factory for adapting StructureNode trees to GenericTreeNode
-// */
-// XXX compiler
-public class StructureGenericTreeNodeFactory implements GenericTreeNodeFactoryI {
-    public GenericTreeNode createGenericTreeNode(Object root,
-                                                 GenericTreeNode parent) {
-                                                    return null;
-    }
-    /**
-	 * @see org.aspectj.testing.compare.adapters.GenericTreeNodeFactoryI#getRootClass()
-	 */
-	public Class getRootClass() {
-		return null;
-	}
-
-}
-//    protected static final String[] MODIFIERS = new String[]
-//    { "strictfp", "abstract", "synchronized", "native",
-//      "final", "transient", "static", "volatile" };
-//    protected static final List MODIFIERS_LIST = Arrays.asList(MODIFIERS);
-//    protected static final String[] ACCESS = new String[]
-//    { "private", "protected", "package", "public", "privileged" };
-//    protected static final List ACCESS_LIST = Arrays.asList(ACCESS);
-//
-//    /** represent empty list of children (todo: use immutable instead) */
-//    public static final List EMPTY_LIST = new ArrayList();
-//    public static final GenericTreeNodeFactoryI SINGLETON
-//        = new StructureGenericTreeNodeFactory();
-//    /** delegate of the factory */
-//    private static final Comparator NODE_COMPARATOR;
-//
-//    static {
-//        SubTypeComparator init = new SubTypeComparator();
-//        init.addComparator(LinkNode.class, LinkNodeComparator.SINGLETON);
-//        init.addComparator(RelationNode.class, RelationNodeComparator.SINGLETON);
-//        init.addComparator(ProgramElementNode.class, ProgramElementNodeComparator.SINGLETON);
-//        init.addComparator(StructureNode.class, StructureNodeComparator.SINGLETON);
-//        GenericTreeNodeComparator gtnc = new GenericTreeNodeComparator(init);
-//        NODE_COMPARATOR = gtnc;
-//    }
-//
-//    private StructureGenericTreeNodeFactory() {}
-//    public Class getRootClass() {
-//        return StructureNode.class;
-//    }
-//
-//    /**
-//     * Adapt Structure model to tree rooted at GenericTreeNode.
-//     * Only takes the current state of a model which does not
-//     * change during the construction of the adapter. If the
-//     * model changes, you can ask the adapter for a newly
-//     * wrapped tree.
-//     * @param root the TreeNode taken as root of a tree to wrap
-//     * @param parent the parent of the resulting GenericTreeNode
-//     * @throws IllegalArgumentException if root is null
-//     *         or if children are not instanceof TreeNode.
-//     */
-//    public GenericTreeNode createGenericTreeNode(Object root,
-//                                                 GenericTreeNode parent) {
-//        if (null == root) {
-//            throw new IllegalArgumentException("null root");
-//        }
-//        if (! (root instanceof StructureNode)) {
-//            throw new IllegalArgumentException("not StructureNode: " + root);
-//        }
-//        GenericTreeNode result = new GenericTreeNode();
-//        StructureNode rootNode = (StructureNode) root;
-//        List kidList = rootNode.getChildren();
-//        List kids = EMPTY_LIST;
-//        // get kids of result
-//        if (null != kidList) {
-//            final int numKids = kidList.size();
-//            ArrayList newKids = new ArrayList(numKids);
-//            ListIterator kidIter = kidList.listIterator();
-//            Object child;
-//            for (int i = 0; i < numKids; i++) {
-//                if (! kidIter.hasNext()) { // items removed from list while iterating
-//                    throw new Error("(! hasNext())");
-//                }
-//                child = kidIter.next();
-//                if (! (child instanceof StructureNode)) {
-//                    throw new Error("! (child instanceof StructureNode)): " + child );
-//                }
-//                newKids.add(createGenericTreeNode((StructureNode) child, result));
-//            }
-//            kids = newKids;
-//        }
-//        // todo: select comparator here - avoids type checking at run time
-//        //result.init(parent, StructureComparator.SINGLETON, rootNode, kids, null);
-//        result.init(parent, NODE_COMPARATOR, rootNode, kids, null);
-//        return result;
-//    }
-//
-//    /** Comparator for GenericTreeNode delegates to handler for nodes... */
-//    static final class GenericTreeNodeComparator implements Comparator {
-//        private final Comparator delegate;
-//        private GenericTreeNodeComparator (Comparator delegate) {
-//            this.delegate = delegate;
-//        }
-//        public final int compare(Object lhs, Object rhs) {
-//            return delegate.compare(((GenericTreeNode)lhs).getNode()
-//                                    , ((GenericTreeNode)lhs).getNode());
-//        }
-//    }
-//
-//    /**
-//     * Comparator for RelationNode delegates to String & boolean comparison of public attributes.
-//     */
-//    static class RelationNodeComparator implements Comparator {
-//        public static Comparator SINGLETON = new RelationNodeComparator();
-//        private RelationNodeComparator () {}
-//        /**
-//         * Comparator for RelationNode uses String & boolean comparison of public attributes
-//         * forwardNavigationName, backNavigationName, associationName, symmetrical, associative.
-//         */
-//        public int compare(Object lhs, Object rhs) {
-//            int result = CompareUtil.compare(lhs, rhs);
-//            if (Integer.MAX_VALUE == result) {
-//                RelationNode lh = (RelationNode) lhs ;
-//                RelationNode rh = (RelationNode) rhs ;
-//                Relation leftRelation = lh.getRelation();
-//                Relation rightRelation = rh.getRelation();
-//                String left = null;
-//                String right = null;
-//                result = CompareUtil.compare(leftRelation, rightRelation);
-//                if (0 == result) {
-//                    left = leftRelation.getForwardNavigationName();
-//                    right = rightRelation.getForwardNavigationName();
-//                    result = CompareUtil.compare(left, right);
-//                }
-//                if (0 == result) {
-//                    left = leftRelation.getBackNavigationName();
-//                    right = rightRelation.getBackNavigationName();
-//                    result = CompareUtil.compare(left, right);
-//                }
-//                if (0 == result) {
-//                    left = leftRelation.getAssociationName();
-//                    right = rightRelation.getAssociationName();
-//                    result = CompareUtil.compare(left, right);
-//                }
-//                boolean l = false;
-//                boolean r = false;
-//                if (0 == result) {
-//                    l = leftRelation.isSymmetrical();
-//                    r = rightRelation.isSymmetrical();
-//                    result = CompareUtil.compare(l, r);
-//                }
-//                if (0 == result) {
-//                    l = leftRelation.isTransitive();
-//                    r = rightRelation.isTransitive();
-//                    result = CompareUtil.compare(l, r);
-//                }
-//            }
-//            return result;
-//        }
-//    }
-//
-//    /** Comparator for ProgramElementNode. */
-//    static class ProgramElementNodeComparator implements Comparator {
-//        public static Comparator SINGLETON = new ProgramElementNodeComparator();
-//        private ProgramElementNodeComparator () {}
-//        public int compare(Object lhs, Object rhs) {
-//            int result = CompareUtil.compare(lhs, rhs);
-//            if (Integer.MAX_VALUE == result) {
-//                ProgramElementNode lh = (ProgramElementNode) lhs ;
-//                ProgramElementNode rh = (ProgramElementNode) rhs ;
-//
-//                boolean rhStmntKind = rh.isCode();
-//                boolean lhStmntKind = lh.isCode();
-//                if (lhStmntKind != rhStmntKind) {
-//                    return (lhStmntKind ? 1 : -1);
-//                }
-//                String left= lh.getKind();
-//                String right= rh.getKind();
-//                // boilerplate
-//                result = CompareUtil.compare(left, right);
-//                if (Integer.MAX_VALUE == result) {
-//                    result = left.compareTo(right);
-//                    if (0 != result) return result;
-//                }
-//                right = rh.getSignature();
-//                left = lh.getSignature();
-//                result = CompareUtil.compare(left, right);
-//                if (Integer.MAX_VALUE == result) {
-//                    result = left.compareTo(right);
-//                    if (0 != result) return result;
-//                }
-//                List rightList = rh.getModifiers();
-//                List leftList = lh.getModifiers();
-//                result = CompareUtil.compare(leftList, rightList, MODIFIERS_LIST);
-//                if (0 != result) return result;
-//
-//                result = compare(rh.getAccessibility(), lh.getAccessibility());
-//                if (0 != result) return result;
-//
-//                right = rh.getDeclaringType();
-//                left = lh.getDeclaringType();
-//                result = CompareUtil.compare(left, right);
-//                if (Integer.MAX_VALUE == result) {
-//                    result = left.compareTo(right);
-//                    if (0 != result) return result;
-//                }
-//
-//                SourceLocation leftSourceLocation = rh.getSourceLocation();
-//                SourceLocation rightSourceLocation = rh.getSourceLocation();
-//                int iright= rightSourceLocation.getLineNumber();
-//                int ileft= leftSourceLocation.getLineNumber();
-//                if (iright != ileft) return (ileft-iright);
-//                iright= rightSourceLocation.getColumnNumber();
-//                ileft= leftSourceLocation.getColumnNumber();
-//                if (iright != ileft) return (ileft-iright);
-//
-//                right= rh.getFormalComment();
-//                left= lh.getFormalComment();
-//                if (Integer.MAX_VALUE == result) {
-//                    result = left.compareTo(right);
-//                    if (0 != result) return result;
-//                }
-//
-//                right = rh.toString();  // ignored? super
-//                left = lh.toString();  // ignored? super
-//                if (Integer.MAX_VALUE == result) {
-//                    result = left.compareTo(right);
-//                    if (0 != result) return result;
-//                }
-//                // ignore source file path - may change?
-//                // lhSourceFilePath = lh.getSourceFilePath(); // ignored
-//                // lh.sourceFilePath = lh.getSourceFilePath(); // ignored
-//                // List rhRelations= rh.getRelations() ; // ignored
-//                // List lhRelations= lh.getRelations();  // ignored
-//                return 0;
-//            }
-//            return result;
-//        }
-//    }
-//    
-//    /** Comparator for LinkNode. */
-//    static class LinkNodeComparator implements Comparator {
-//        public static Comparator SINGLETON = new LinkNodeComparator();
-//        private LinkNodeComparator () {}
-//        public int compare(Object lhs, Object rhs) {
-//            int result = CompareUtil.compare(lhs, rhs);
-//            if (Integer.MAX_VALUE == result) {
-//                LinkNode lh = (LinkNode) lhs ;
-//                LinkNode rh = (LinkNode) rhs ;
-//                // LinkNode only has child and lexical name in toString
-//                result = lh.toString().compareTo(rh.toString());
-//            }
-//            return result;
-//        }
-//    }   // class LinkNodeComparator
-//
-//    /**
-//     * Comparator for StructureNode.
-//     * <li>todo: implement comparators for each StructureNode subtype</li>
-//     */
-//    static class StructureNodeComparator implements Comparator {
-//        public static Comparator SINGLETON = new StructureNodeComparator();
-//        private StructureNodeComparator () {}
-//        public int compare(Object lhs, Object rhs) {
-//            int result = CompareUtil.compare(lhs, rhs);
-//            if (Integer.MAX_VALUE == result) {
-//                Class lhClass = lhs.getClass() ;
-//                Class rhClass = rhs.getClass() ;
-//                if ((StructureNode.class.isAssignableFrom(lhClass))
-//                    && (StructureNode.class.isAssignableFrom(rhClass))) {
-//                    StructureNode lh = (StructureNode) lhs ;
-//                    StructureNode rh = (StructureNode) rhs ;
-//                    Object lhObject = lh.getName(); // todo: weak name-based comparison
-//                    Object rhObject = rh.getName();
-//                    result = CompareUtil.compare(lhs, rhs);
-//                    if (Integer.MAX_VALUE == result) {
-//                        result = lhObject.toString().compareTo(rhObject.toString());
-//                    }
-//                } else { // urk - broken unless wrapper
-//                    result = lhs.toString().compareTo(rhs.toString());
-//                }
-//            }
-//            return result;
-//        }
-//    }
-//}
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/SubTypeComparator.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/SubTypeComparator.java
deleted file mode 100644
index 3094fdb64..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/SubTypeComparator.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-package org.aspectj.testing.compare.adapters;
-
-import org.aspectj.testing.compare.CompareUtil;
-import java.util.Comparator;
-
-// for testing code
-import java.util.*;
-import java.text.Collator;
-
-/** 
- * This adopts pairs of [Class, Comparator]
- * and implements compare by delegation thereto, 
- * selecting the first added where the classes of the both inputs
- * are assignable to the pair Class.
- * It first applies the null-semantics of CompareUtil.compare(..),
- * which holds that null values are less-than non-null values,
- * and that two nulls are equal.
- * Note that this class uses Object.equals(..)'s default reference
- * equality, so two SubTypeComparator with the same list 
- * of delegates will NOT be considered equal.
- * <p>todo: This class is not thread-safe.
- * <p>todo: immutable: final list copy on construction to implement equals??
- */
-public class SubTypeComparator implements Comparator {
-	/** order-sensitive comparators collection */
-	private Vector comparators;
-	/** copy of comparators for compare method */
-	private Struct[] cache;
-
-	/** default constructor */
-	public SubTypeComparator () {
-		comparators = new Vector();
-	}
-
-	/**
-	 * Return true if the Class is in the list of comparators
-	 * as of the initial execution of the method.
-	 * @param c the Class to look for a comparator
-	 * @return true of comparator exists for c
-	 */
-	private boolean contains(Class c) {
-		final int size = comparators.size();
-		for (int i = 0; i < size; i++) {
-			if (c == ((Struct) comparators.elementAt(i)).accepts) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Get copy of comparators for compare operation.
-	 */
-	private Struct[] getComparators() { // todo: sync on comparators
-		if ((null == cache) || (cache.length < comparators.size())) {
-			cache = new Struct[comparators.size()];
-			comparators.copyInto(cache);
-		}
-		return cache;
-	}
-
-	/**
-	 * Add a Class, Comparator pair as delegate when
-	 * both input are assignable to Class.
-	 * Note that additions are checked in the order they are added,
-	 * so add the lowest subtypes first.  (i.e., if you add
-	 * a comparator for Class Object first, none of the others
-	 * will ever match.)
-	 * @param accepts the Class supertype of objects to accept
-	 * @param comparator the Comparator to use on such objects
-	 * @return false if not added, because either input is null
-	 *         or because the Class is represented already.
-	 */
-	public final boolean addComparator(Class accepts, Comparator comparator) {
-		if ((null == accepts) || (null == comparator)
-			|| (contains(accepts))) {
-			return false;
-		}
-		comparators.addElement(new Struct(accepts, comparator));
-		return true;
-	}
-
-	/** 
-	 * This implements compare by delegating
-	 * to the first input Comparator 
-	 * where the class of the both input
-	 * is assignable to the pair Class.
-	 * It first enforces the null-semantics of CompareUtil.compare(..).
-	 * @throws ClassCastException if both input are not null and
-	 *         they are not assignable to any registered Comparator.
-	 */
-	public final int compare(Object lhs, Object rhs) {
-		int result = CompareUtil.compare(lhs, rhs);
-		if (Integer.MAX_VALUE == result) {
-			Class lhClass = lhs.getClass() ;
-			Class rhClass = rhs.getClass() ;
-			Struct[] comp = getComparators();
-			Class compClass;
-			for (int i = 0; i < comp.length; i++) {
-				compClass = comp[i].accepts;
-				if ((compClass.isAssignableFrom(lhClass))
-					&& (compClass.isAssignableFrom(lhClass))) {
-					return comp[i].comparator.compare(lhs, rhs);
-				}
-			}
-			// not found - throw ClassCastException
-			String mssg = "Unable to find Comparator for "
-				+ "lhs Class: " + lhClass.getName()
-				+ " rhs Class: " + rhClass.getName();
-			throw new ClassCastException(mssg);
-		}
-		return result;
-	}
-
-	/** 
-	 * (unnecessary) Struct to hold class-comparator pair 
-	 * is preparation for using collections
-	 */
-	static class Struct {
-		public final Class accepts;
-		public final Comparator comparator;
-		/**
-		 * @param accepts the Class to accept input for - not null
-		 * @param comparator the Comparator to compare input with - not null
-		 */
-		public Struct(Class accepts,Comparator comparator) {
-			this.accepts = accepts;
-			this.comparator = comparator;
-		}
-		/** delegate to accept hashcode */
-		public int hashCode() { return accepts.hashCode() ; }
-		/** WARNING: fast comparison based only on accept key reference identity */
-		public boolean equals(Object o) {
-			return ((null != o) && (o instanceof Struct)
-					&& (accepts == ((Struct)o).accepts));
-		}
-	} // class Struct
-
-	//----------------------------------------------- test code 
-	/** test code */
-	static class Test { // todo move elsewhere
-		public void runTest(String[] args) {
-			if ((null == args) || (1 > args.length)) {
-				args = new String[] { "one", "two", "THREE", "FOUR", "fIVE", "6" };
-			}
-			SubTypeComparator me = new SubTypeComparator();
-			String[] copy = new String[args.length];
-			System.arraycopy(args, 0, copy, 0, copy.length);
-			List list = Arrays.asList(args);
-			Throwable result  = test(me, list);
-			if ((null == result)
-				 && (!ClassCastException.class.isAssignableFrom(result.getClass()))) {
-				System.err.println("FAIL: expected cce: " + result);
-			}
-			me.addComparator(String.class, Collator.getInstance());
-			me.addComparator(Object.class, new Comparator () { 
-					public int compare (Object lhs, Object rhs) { 
-						throw new Error("never used");
-					}});
-			result  = test(me, list);
-			if (null != result) {
-				if (ClassCastException.class.isAssignableFrom(result.getClass())) {
-					System.err.println("FAIL: unexpected cce: " + result);
-				} else {
-					System.err.println("FAIL: unexpected Throwable: " + result);
-				}
-			}
-			// heterogeneous - pick Object
-			Object[] temp = new Object[] { "string", new Integer(1) };
-			result  = test(me, Arrays.asList(temp));
-			if ((null == result)
-				 && (!Error.class.isAssignableFrom(result.getClass()))) {
-				System.err.println("FAIL: expected Error: " + result);
-			}
-			
-			StringBuffer toPrint = print(Arrays.asList(copy), null);
-			toPrint.append("\n");
-			print(list, toPrint);
-			System.err.println(toPrint.toString());
-		}
-
-		StringBuffer print(List list, StringBuffer sb) {
-			if (null == sb) sb = new StringBuffer();
-			sb.append("[");
-			ListIterator iter = list.listIterator();
-			while (iter.hasNext()) {
-				sb.append(iter.next().toString());
-				if (iter.hasNext()) sb.append(", ");
-			}
-			sb.append("]");
-			return sb;
-		}
-
-		/**
-		 * run comparison, return true if got expected exception
-		 */
-		Throwable test(Comparator c, List l) {
-			try {
-				Collections.sort(l,c);
-				return null;
-			} catch (Throwable r) {
-				return r;
-			}
-		}
-	} // class Test
-
-	/** invoke Test.runTest(args) todo remove */
-	public static void main(String[] args) {
-		new Test().runTest(args);
-	}
-} // class SubTypeComparator
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/package.html b/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/package.html
deleted file mode 100644
index c2d839ed1..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/adapters/package.html
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-<body>
-These adapters facilitate using the GenericTreeNode
-comparison utilities on different types of trees.
-The classes currently in this package support Swing
-<code>TreeNode</code> and AspectJ compiler <code>StructureNode</code>.
-
-<p>
-<code>Structure</code> supports a command-line interface for
-compiling <code>StructureNode</code> trees using 
-<code>AspectJCompiler</code> and saving 
-or loading them using serialization.  Once loaded, two trees
-can be compared using the <code>GenericTreeNode.traverse(..)</code> method,
-providing it the appropriate visitors and comparators to implement
-a comparison of the expected and actual structure trees and
-report on any differences.  (This is used to validate that
-changes to the structure tree are backwards compatible with
-trees from previous compiles, since the structure tree is
-effectively exported from the compiler to the IDE tools.)
-
-<p>
-If you want to support new trees,
-<code>GenericTreeNodeFactoryI</code> is the interface to implement.
-It specifies a factory to provide a <code>Comparator</code> based
-on a given pair to be compared. This means that you can
-use (or generate) comparators based on specific pairs.
-Usually you will implement only for the target type,
-so your factory may be final and always return a 
-singleton <code>Comparator.</code>
-<p>
-The <code>SubTypeComparator</code> implements a <code>Comparator</code>
-container that acts as a <code>Comparator</code> by delegating to
-contained <code>Comparator</code>s registered along with the class of the input
-they accept.  This permits you to write type-specific
-<code>Comparator</code>s for heterogeneous trees.  It does require
-both members of the comparison be assignable to the
-target class.
-
-<p> 
-<code>StructureGenericTreeNodeFactory</code> is an implementation of
-<code>GenericTreeNodeFactoryI</code> for StructureNode trees.  It
-contains comparator classes for <code>RelationNode</code>, <code>LinkNode,</code>
-and <code>ProgramElementNode</code>, 
-combined using a <code>SubTypeComparator.</code>
-<p> 
-<code>JTreeNodeGenericTreeNodeFactory</code> is an implementation of
-<code>GenericTreeNodeFactoryI</code>  for Swing <code>TreeNode</code>'s, done only
-for testing purposes.
-</body>
-</html>
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/package.html b/aspectj-attic/testing-src/org/aspectj/testing/compare/package.html
deleted file mode 100644
index 6bfec163d..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/package.html
+++ /dev/null
@@ -1,128 +0,0 @@
-<html>
-<body>
-This package implements a general tree comparison as a
-special case of visiting generic trees pairwise.
-Trees are wrapped as <code>GenericTreeNode</code>, which has a static
-method <code>boolean traverse(..)</code> which accepts
-a visitor and traverses a pair of trees, calling the
-visitor on each.
-<p>This package supports four forms of generality 
-through the following classes:
-<table border="+1">
-<tr><th>Classes</th>
-    <th>Capability</th></tr>
-<tr><td valign="top">GenericTreeNode</td>
-   <td>Able to handle trees of varying types
-       by wrapping in a generic form.<td>
-   </tr>
-<tr><td valign="top">GenericTreeNodesVisitorI, GenericTreeNode.traverse(..)</td>
-    <td>Can handle any type of pairwise visitor function
-        by accepting visitor in the traverse method.</td>
-   </tr>
-<tr><td valign="top">{java.util.Comparator}, GenericTreeNode.getComparator()</td>
-    <td>The object comparison can be sensitive to the type
-    of the object on a per-object basis, established during
-    the process of wrapping the tree.</td>
-   </tr>
-<tr><td valign="top">GenericTreeListOrdererI, GenericTreeListOrdererFactoryI</td>
-    <td>The ordering of children can be appropriate to
-    the objective of the traversal. e.g., when computing
-    "set intersection" rather than "list equals", the
-    order of children might be changed to align matching
-    children for the visits.
-    <br>This ordering can be determined as appropriate for each
-    list comparison by implementing a factory which selects
-    from the appropriate orderers.  Any factory product is used
-    by the traverse(..) method to order children before
-    visiting.</td>
-   <td></td>
-   </tr>
-</table>
-
-<p><u>Supported variants</u>:
-The following variants are implemented or planned using the components above:
-<table border="1">
-<tr><th>Component</th><th>Description</th></tr>
-<tr><td colspan=2>Current</th></tr>
-<tr><td>GenericTreeNode.PRINTALL</td>
-    <td>A visitor which prints out the entire tree.</td></tr>
-<tr><td>GenericTreeNode.PRINTERR</td>
-    <td>A visitor which prints the nonmatching pairs.</td></tr>
-<tr><td>GenericTreeNode.EXACT</td>
-    <td>A visitor which returns false if any pairs do not match.</td></tr>
-<tr><td>TreeCompare</td>
-    <td>A sample program to read in serialized trees and compare them.
-        (but see Structure in the compare subpackage for a better example) </td></tr>
-<tr><td>CompareUtil</td>
-    <td>Misc comparison utilities (e.g., for short-circuiting comparisons).</td></tr>
-<tr><td colspan=2>Planned</th></tr>
-<tr><td>GenericTreeNode.KIDDIFF</td>
-    <td>A visitor which calculates tree differences, using ordering children
-	    (catches swaps, missed or added elements, within children)</td></tr>
-<tr><td>GenericTreeNode.TREEDIFF</td>
-    <td>A visitor which calculates tree differences, accumulating the tree
-	    (catches swaps, missed or added elements, throughout tree.)</td></tr>
-</table>
-
-<p><u>Use</u>:
-  Run TreeCompare to use the comparer from the command line on a supported tree,
-   (currently only the Swing TreeNode implemented as DefaultMutableTreeNode).
-
-<p><u>Programming</u>:<br>
-To support a new tree, see the Structure example in the compare subpackage
-or use example of the Swing TreeNode:
-<li>Write an adapter that uses GenericTreeNode to wrap your tree nodes</li>
-<li>Write a factory that produces a wrapped tree</li>
-<li>Write a Comparator that compares the underlying node object 
-    to include with each node object wrapped. Be sure to implement
-    the Comparator.equals(Object) method correctly, i.e., returning
-    true when it is equivalent to another comparator.  It is best 
-    to use a singleton for each type of node you support. </li>
-<li>Optionally write a visitor to perform whatever operations you wish.
-    Note that visitors must tolerate a single null input in order to
-    completely traverse unmatching trees.</li>
-<li>To perform operations requiring preprocessing of child List's,
-    write children orderer(s) and provide a factory to select them.</li>
-
-<p>To design new algorithms/applications, bear in mind the main tools:
-<li>The comparator that follows the node object</li>
-<li>The visitor that traverses the tree </li>
-<li>The child orderer that may preprocess the child lists </li>
-<br>In particular, when going beyond pair-wise comparisons to
-    list-wise or tree-wise comparisons, you'll have to decide
-    where to put the appropriate logic.  You may have a relatively
-    lightweight visitor and a heavyweight orderer, or no
-    orderer at all. In that case, you may need to invoke a 
-    special method on your visitor after the traversal completes
-    to do any final processing.
-
-<h2>Future Work</h2>:
-<p><u>Smarter group comparisons</u>:
-<br>Does calculating maps help with diagnosing problems?
-<pre>
-Given two lists,
-  A [ a, b, c, d, e, f, g, h ]
-  B [ a, e, c, d, b, g, h ]
-The result should say:
-  - B swapped order of e and b
-  - B omitted f
-Note the match-map (index of matching element, if any):
-  A->B [ 0, 4, 2, 3, 1, -, 5, 6 ]
-  B->A [ 0, 4, 2, 3, 1, 6, 7 ]
-the shift-map (difference between expected and actual order):
-  A->B [ 0, 3, 0, 0, -3, -, -1, -1 ]
-  B->A [ 0, 3, 0, 0, -3, 1, 1 ]
-
-Thus:
-- detect swaps as complementary out-of-index order pairs
-  (todo: three-way or n-ary?)
-  - fix or ignore swaps
-- detect shifts as complementary series
-  where shift-width n is +/- for both
-  - -n => 
-    - if negative element is actual, n elements omitted
-    - if negative element is expected, n elements added
-<pre>
-
-</body>
-</html>
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/taskdefs/CompareFiles.java b/aspectj-attic/testing-src/org/aspectj/testing/taskdefs/CompareFiles.java
deleted file mode 100644
index fe1b760ac..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/taskdefs/CompareFiles.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/* *******************************************************************
- * 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 
- * ******************************************************************/
-
-
-package org.aspectj.testing.taskdefs;
-
-import java.io.File;
-import java.io.IOException;
-import org.apache.tools.ant.*;
-
-/**
- * Wrap file comparison utility as ant taskdef.
- * (Whitespace semantics track the String.trim() and StringTokenizer class.)
- * <table>
- * <tr><td>lhsFile</td><td>path to left-hand-side file to compare (required)</td></tr>
- * <tr><td>rhsFile</td><td>path to right-hand-side file to compare (required)</td></tr>
- * <tr><td>output</td><td>path to output file (System.out otherwise)</td></tr>
- * <tr><td>ignoreCase</td><td>convert to uppercase before comparison (boolean yes/no)</td></tr>
- * <tr><td>trimWhitespace</td><td>ignore leading/trailing white space(boolean yes/no)</td></tr>
- * <tr><td>collapseWhitespace</td><td>convert all white space runs to a single space (boolean yes/no)</td></tr>
- * <tr><td>filterSpec</td><td>all specifications for a filter, based on the RegexpFilter class
- *               (currently, syntax: <code>{file | {-i|-t|-b|-s <pattern>|-s <patternFile>}..}</code></td></tr>
- * </table>
- * @see org.aspectj.testing.compare.RegexpFilter#init(String[],RegexpFilter)
- */
-public class CompareFiles extends org.apache.tools.ant.Task {
-    /*
-      Unable to implement multiple inheritance except by delegation:
-      - Task subclass must be outer or ant throws InstantiationException
-      - if/since outer, the subclass getter/setters cannot refer to 
-        protected fields in worker superclass absent inner worker 
-        subclass delegate methods.  yuck.
-      - getting access errors when trying to use the RuntimeConfigurable
-        to initialize the task.  Looking at the Ant code, it does not
-        appear to be used for tasks??  I found none using it and the
-        initialization seems wrong...
-    */
-    final private Worker worker;
-    public CompareFiles() { 
-        worker = new Worker();
-    }
-    protected File lhsFile;
-    protected File rhsFile;
-    public void setLhsFile(File file)             { lhsFile = file; }
-    public void setRhsFile(File file)             { rhsFile = file; }
-    public void setOutput(File file)              { worker.setOutput(file); }
-    public void setFilterSpec(String str)         { worker.setFilterSpec(str); }
-    public void setCollapseWhitespace(boolean ok) { worker.setCollapseWhitespace(ok); }
-    public void setTrimWhitespace(boolean ok)     { worker.setTrimWhitespace(ok); }
-    public void setIgnoreCase(boolean ok)         { worker.setIgnoreCase(ok); }
-    public void execute() throws BuildException   { 
-        if (!lhsFile.canRead()) {
-            log("FAIL taskdefs.CompareFiles: bad lhsFile: " + lhsFile);
-        } else if (!rhsFile.canRead()) {
-            log("FAIL taskdefs.CompareFiles: bad rhsFile: " + rhsFile);
-        } else if (rhsFile.isDirectory() != lhsFile.isDirectory()) {
-            log("FAIL taskdefs.CompareFiles: both must be dirs."
-                + " lhsFile=" + lhsFile
-                + " rhsFile=" + rhsFile);
-        } else {
-            worker.dodiff(lhsFile, rhsFile); 
-        }
-    }
-} // class CompareFiles
-
-/** worker class exposes state and converts Exception to BuildException */
-class Worker extends org.aspectj.testing.compare.CompareFiles {
-    String spec = null;
-    public void setOutput(File file)              { output = file; }
-    public void setCollapseWhitespace(boolean ok) { collapseWhitespace = ok; }
-    public void setTrimWhitespace(boolean ok)     { trimWhitespace = ok; }
-    public void setIgnoreCase(boolean ok)         { ignoreCase = ok; }
-    public void setFilterSpec(String str)         { spec = str; }
-    public void initFilter() {
-        if (null != spec) {
-            initFilter(spec, false);
-        }
-    }
-
-    public void dodiff(File lhsFile, File rhsFile) throws BuildException {
-        initFilter();
-        try {
-            super.diff(lhsFile, rhsFile);
-        } catch (IOException t) {
-            String s = t.getClass().getName() + ": " + t.getMessage();
-            throw new BuildException(s, t);
-        } catch (Throwable e) {
-            String s = e.getClass().getName() + ": " + e.getMessage();
-            throw new BuildException("Error - " + s, e);
-        } 
-    }    
-} // class CompareFiles$Worker
-