mavenizing build - wip

8 files changed, 1369 insertions, 0 deletions

diff --git a/build/src/test/java/org/aspectj/build/BuildModuleTests.java b/build/src/test/java/org/aspectj/build/BuildModuleTests.java
new file mode 100644
index 000000000..52510c75f
--- /dev/null
+++ b/build/src/test/java/org/aspectj/build/BuildModuleTests.java
@@ -0,0 +1,304 @@
+package org.aspectj.build;
+/* *******************************************************************
+ * 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 Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+
+// default package
+
+import org.aspectj.internal.tools.ant.taskdefs.Checklics;
+import org.aspectj.internal.tools.build.Builder;
+import org.aspectj.internal.tools.build.Util;
+import org.aspectj.internal.tools.build.UtilsTest;
+import org.aspectj.internal.build.BuildModuleTest;
+import org.aspectj.internal.build.ModulesTest;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import junit.framework.*;
+
+/**
+ * Master suite for build module
+ * and test of all source directories for correct licenses and known file types.
+ */
+public class BuildModuleTests extends TestCase {
+
+    /** if true, then replace old headers with new first */
+    private static final boolean replacing = false; // XXX never to enable again...
+    
+    /** replace commented out below - if any replace failed, halt all */
+    private static boolean replaceFailed = false;
+    
+    private static final String BASE_DIR = ".." + File.separator;
+    private static final String[] JDT_SOURCE_DIRS = new String[] {};
+
+    public static Test suite() { 
+        TestSuite suite = new TestSuite("Build module tests");
+        suite.addTestSuite(BuildModuleTests.class); 
+        suite.addTestSuite(BuildModuleTest.class); 
+        suite.addTestSuite(ModulesTest.class); 
+        suite.addTestSuite(UtilsTest.class); 
+        return suite;
+    }
+
+    /** @return String tag of license if not default */
+    public static String getLicense(String module) {
+        return null; // use permissive default
+    }
+
+    final static List<String> SOURCE_NAMES = Collections.unmodifiableList(
+            Arrays.asList(new String[]{"src", "testsrc", "java5-src", "java5-testsrc", "aspectj-src"}));
+
+    /**
+     * @param moduleDir
+     * @return
+     */
+    private static File[] findSourceRoots(File moduleDir) {
+        ArrayList<File> result = new ArrayList<File>();
+        for (String name: SOURCE_NAMES) {
+            File srcDir = new File(moduleDir, name);
+            if (srcDir.canRead() && srcDir.isDirectory()) {
+                result.add(srcDir);
+            }
+        }
+        return (File[]) result.toArray(new File[0]);
+    }
+
+    public BuildModuleTests(String name) { super(name); }
+
+    public void testSuffixList() {
+        if (!UnknownFileCheck.STATIC_ERRORS.isEmpty()) {
+            fail("" + UnknownFileCheck.STATIC_ERRORS);
+        }
+    }
+    public void testLicense_ajbrowser() {
+        checkLicense("ajbrowser");    
+    }
+    public void testLicense_ajde() {
+        checkLicense("ajde");    
+    }
+    public void testLicense_aspectj5rt() {
+        checkLicense("aspectj5rt");    
+    }
+    public void testLicense_asm() {
+        checkLicense("asm");    
+    }
+
+    public void testLicense_bridge() {
+        checkLicense("bridge");    
+    }
+    public void testLicense_build() {
+        checkLicense("build");    
+    }
+    public void testLicense_org_aspectj_ajdt_core() {
+        checkLicense("org.aspectj.ajdt.core");    
+    }
+    public void testLicense_org_aspectj_lib() {
+        checkLicense("org.aspectj.lib");    
+    }
+    public void testLicense_org_eclipse_jdt_core() {
+        final String mod = "org.eclipse.jdt.core";
+        final String pre = BASE_DIR + mod + File.separator;
+        for (int i = 0; i < JDT_SOURCE_DIRS.length; i++) {
+            checkSourceDirectory(new File(pre + JDT_SOURCE_DIRS[i]), mod);    
+		}
+    }
+    
+    public void testLicense_runtime() {
+        checkLicense("runtime");    
+    }
+    public void testLicense_taskdefs() {
+        checkLicense("taskdefs");    
+    }
+    public void testLicense_testing() {
+        checkLicense("testing");    
+    }
+    public void testLicense_testing_client() {
+        checkLicense("testing-client");    
+    }
+    public void testLicense_testing_drivers() {
+        checkLicense("testing-drivers");    
+    }
+    public void testLicense_testing_util() {
+        checkLicense("testing-util");    
+    }
+    public void testLicense_util() {
+        checkLicense("util");    
+    }
+    public void testLicense_weaver() {
+        String module = "weaver";
+        // skip (testdata) packages fluffy, reflect
+        checkSourceDirectory(new File(Util.path(new String[] {"..", module, "src"})), module);
+        checkSourceDirectory(new File(Util.path(new String[] {"..", module, "testsrc", "org"})), module);
+    }
+    
+    public void testLicense_ajdoc() {
+        checkLicense("ajdoc");
+    }
+    
+    public void testLicense_loadtime() {
+        checkLicense("loadtime");
+    }
+    
+    public void testLicense_loadtime5() {
+        checkLicense("loadtime5");
+    }
+    
+    public void testLicense_weaver5() {
+        checkLicense("weaver5");
+    }
+
+    void checkLicense(String module) {
+        File moduleDir = new File(Util.path("..", module));
+        File[] srcDirs = findSourceRoots(moduleDir);
+        for (int i = 0; i < srcDirs.length; i++) {
+            checkSourceDirectory(srcDirs[i], module);
+        }
+    }
+    
+    void checkSourceDirectory(File srcDir, String module) {
+        final String label = "source dir " + srcDir + " (module " + module + ")";
+        assertTrue(label,  (srcDir.exists() && srcDir.isDirectory()));
+        String license = getLicense(module);
+//        if (replacing) {
+//            if (replacing && true) {
+//                throw new Error("replacing done - code left for other replaces");
+//            }
+//            assertTrue("aborting - replace failed", !replaceFailed);
+//            // do the replace
+//            int fails = Checklics.runDirect(moduleDir.getPath(), "replace-headers");
+//            replaceFailed = (0 != fails);
+//            assertTrue(!replaceFailed);
+//            license = Checklics.CPL_IBM_PARC_XEROX_TAG;
+//        }
+        int fails = Checklics.runDirect(srcDir.getPath(), license, true);
+        if (0 != fails) {
+            if (replacing) {
+                BuildModuleTests.replaceFailed = true;
+            }
+            assertTrue(label + " fails", !BuildModuleTests.replaceFailed);
+        }
+        
+        // separate check to verify all file types (suffixes) are known
+        if (!"testsrc".equals(srcDir.getName())) {
+            ArrayList<File> unknownFiles = new ArrayList<File>();
+            UnknownFileCheck.SINGLETON.unknownFiles(srcDir, unknownFiles);
+            if (!unknownFiles.isEmpty()) {
+                String s = "unknown files (see readme-build-module.html to "
+                    + "update Builder.properties resource patterns): ";
+                fail(s + unknownFiles);
+            }
+        }
+    }
+    /**
+     * Check tree for files not managed by the build system
+     * (either source files or managed as resources).  
+     * This should pick up situations where new kinds of resources are added
+     * to the tree without updating the build script patterns to pick them
+     * up.
+     * @see Builder#BINARY_SOURCE_PATTERN  
+     * @see Builder#RESOURCE_PATTERN
+     * @see org.aspectj.util.FileUtil#SOURCE_SUFFIXES
+     */
+    static class UnknownFileCheck implements FileFilter {
+        private static final UnknownFileCheck SINGLETON = new UnknownFileCheck();
+        private static final ArrayList<String> STATIC_ERRORS = new ArrayList<String>();
+        // Builder.BINARY_SOURCE_PATTERN and Builder.RESOURCE_PATTERN
+        public static final List<String> KNOWN_SUFFIXES;
+
+        static {
+            List<String> suffixes = new ArrayList<String>();
+            // sources from org.aspectj.util.FileUtil.SOURCE_SUFFIXES
+            suffixes.add(".aj");
+            suffixes.add(".java");
+            
+            // just because we know...
+            suffixes.add(".html");
+
+            // others from Builder
+            final String input = Builder.BINARY_SOURCE_PATTERN 
+                + "," + Builder.RESOURCE_PATTERN;
+            StringTokenizer st = new StringTokenizer(input, ",");
+            while (st.hasMoreTokens()) {
+                String token = st.nextToken().trim();
+                if (0 == token.length()) {
+                    continue;
+                }
+                if (token.startsWith("**/*.")) {
+                    token = token.substring(4);
+                } else if (token.startsWith("*.")) {
+                    token = token.substring(1);
+                } else {
+                    String s = input + " at \"" + token + "\"";
+                    STATIC_ERRORS.add("unable to read pattern: " + s);
+                }
+                suffixes.add(token);
+            }            
+            KNOWN_SUFFIXES = Collections.unmodifiableList(suffixes);
+        }
+        
+        private UnknownFileCheck() {
+            
+        }
+        /**
+         * Return true if input File file is a valid path to a directory 
+         * or to a file
+         * which is not hidden (starts with .)
+         * and does not have a known suffix.
+         * Caller is responsible for pruning CVS directories
+         * @return true iff unknown or a directory
+         */
+        public boolean accept(File file) {
+            if (null == file) {
+                return false;
+            }            
+            if (file.isDirectory()) {
+                return file.canRead();
+            }
+
+            String name = file.getName();
+            if ("CVS".equals(name) || name.startsWith(".")) {
+                return false;
+            }
+            // to do not accepting uppercase suffixes...
+            for (String suffix: KNOWN_SUFFIXES) {
+                if (name.endsWith(suffix)) {
+                    return false;
+                }
+            }
+            return true;
+            
+        }
+        void unknownFiles(File dir, ArrayList<File> results) {
+            File[] files = dir.listFiles(this);
+            for (int j = 0; j < files.length; j++) {
+                File file = files[j];
+                if (file.isDirectory()) {
+                    String name = file.getName();
+                    if (!("CVS".equals(name))) {
+                        unknownFiles(file, results);
+                    }
+                } else {
+                    results.add(file);
+                }
+            }
+        }
+        
+    }
+}  
+
diff --git a/build/src/test/java/org/aspectj/internal/build/BuildClasspathTest.java b/build/src/test/java/org/aspectj/internal/build/BuildClasspathTest.java
new file mode 100644
index 000000000..b8cb4b896
--- /dev/null
+++ b/build/src/test/java/org/aspectj/internal/build/BuildClasspathTest.java
@@ -0,0 +1,67 @@
+/* *******************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: 
+ *     Wes Isberg       initial implementation 
+ * ******************************************************************/
+
+
+package org.aspectj.internal.build;
+
+import java.io.File;
+
+import junit.framework.TestCase;
+
+import org.aspectj.internal.tools.build.Messager;
+import org.aspectj.internal.tools.build.Module;
+import org.aspectj.internal.tools.build.Modules;
+import org.aspectj.internal.tools.build.Result;
+import org.aspectj.internal.tools.build.Result.Kind;
+
+public class BuildClasspathTest extends TestCase {
+
+    public void testKindsGet() {
+        Kind kind = Result.kind(Result.NORMAL, Result.ASSEMBLE);
+        same(kind, "RELEASE_ALL");
+        kind = Result.kind(Result.NORMAL, !Result.ASSEMBLE);
+        same(kind, "RELEASE");
+        kind = Result.kind(!Result.NORMAL, Result.ASSEMBLE);
+        same(kind, "TEST_ALL");
+        kind = Result.kind(!Result.NORMAL, !Result.ASSEMBLE);
+        same(kind, "TEST");
+    }
+    private void same(Kind kind, String name) {
+        if (!name.equals(kind.toString())) {
+            fail("expected \"" + name + "\" got \"" + kind + "\"");
+        }
+    }
+    public void testClasspath() {
+        Messager handler = new Messager();
+        File baseDir = new File("..");
+        File jarDir = new File("../aj-build/jars");
+        Modules modules = new Modules(baseDir, jarDir, handler);
+        Module module = modules.getModule("ajbrowser");
+        Kind kind = Result.kind(Result.NORMAL, !Result.ASSEMBLE);
+        Result result = module.getResult(kind);
+        print(result);
+    }
+    public void testBuildClasspath() {
+        Messager handler = new Messager();
+        File baseDir = new File("..");
+        File jarDir = new File("../aj-build/jars");
+        Modules modules = new Modules(baseDir, jarDir, handler);
+        Module module = modules.getModule("build");
+        Kind kind = Result.kind(Result.NORMAL, !Result.ASSEMBLE);
+        Result result = module.getResult(kind);
+        print(result);
+    }
+    private void print(Result result) {
+        System.out.println(result + " libjars" + result.getLibJars());
+        System.out.println(result + " required" + result.getRequired());
+    }
+}
diff --git a/build/src/test/java/org/aspectj/internal/build/BuildModuleTest.java b/build/src/test/java/org/aspectj/internal/build/BuildModuleTest.java
new file mode 100644
index 000000000..bc96bef6a
--- /dev/null
+++ b/build/src/test/java/org/aspectj/internal/build/BuildModuleTest.java
@@ -0,0 +1,468 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC),
+ *               2005-2006 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+package org.aspectj.internal.build;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipException;
+import java.util.zip.ZipFile;
+
+import junit.framework.TestCase;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.taskdefs.Java;
+import org.apache.tools.ant.types.Path;
+import org.apache.tools.ant.types.Commandline.Argument;
+import org.aspectj.internal.tools.ant.taskdefs.BuildModule;
+import org.aspectj.internal.tools.ant.taskdefs.Checklics;
+import org.aspectj.internal.tools.build.Util;
+
+/**
+ * Test our integrated taskdef build.
+ * This responds to two environment variables:
+ * (1) run.build.tests must be defined before
+ *   tests that build the tree (and hence take minutes)
+ *   will run;
+ * (2) build.config takes the same form as it does for the
+ *   builder task, e.g., "useEclipseCompiles" will avoid
+ *   recompiling with Javac and adopt classes in the 
+ *   {module}/bin directories.
+ */
+public class BuildModuleTest extends TestCase {
+
+    private static boolean printInfoMessages = false;
+    private static boolean printedMessage;
+    private static final boolean REMOVE_JARS_AFTER_DEBUGGING = true;
+    // to just build one module verbosely
+    private static final String[] DEBUGS  
+        = {};
+
+    // skip those requiring ajdoc, which requires tools.jar
+    // also skip those requiring java5 unless manually set up
+    // also skip big ones to avoid slowing the build too much
+    private static final String[] SKIPS 
+        //= {};
+       = {"aspectjtools", "ajdoc", "aspectj5rt", "run-all-junit-tests",
+        "ajbrowser", "testing", "testing-drivers", "org.aspectj.ajdt.core", "weaver"};
+
+    private static final String SKIP_MESSAGE = 
+        "BuildModuleTest: Define \"run.build.tests\" as a system "
+        + "property to run tests to build ";
+    private static final String BUILD_CONFIG;
+    static {
+        String config = null;
+        try {
+            config = System.getProperty("build.config");
+        } catch (Throwable t) {
+            // ignore
+        }
+        BUILD_CONFIG = config;
+        if (printInfoMessages) {
+            System.out.println("BuildModuleTest build.config: " + config);
+        }
+    }
+        
+    ArrayList<File> tempFiles = new ArrayList<File>();
+    private File jarDir;
+    private boolean deleteJars;
+    boolean building;  // must be enabled for tests to run
+    
+	public BuildModuleTest(String name) {
+		super(name);
+        building = Boolean.getBoolean("run.build.tests");
+	}
+    protected void setUp() {
+        // change to view whether prior output is used
+        deleteJars = true; // todo
+    }
+
+    protected void tearDown() throws Exception {
+		super.tearDown();
+        if (debugging() && !REMOVE_JARS_AFTER_DEBUGGING) {
+            if (0 < tempFiles.size()) {
+                System.err.println("debugging files left: " + tempFiles);
+            }
+            return;
+        }
+        deleteTempFiles();
+	}
+    
+    protected void deleteTempFiles() {
+        for (Iterator iter = tempFiles.iterator(); iter.hasNext();) {
+            File file = (File) iter.next();
+            if (!Util.delete(file)) {
+                File[] list = file.listFiles();
+                if (!Util.isEmpty(list)) {                
+                    StringBuffer sb = new StringBuffer();
+                    sb.append("warning: BuildModuleTest unable to delete ");
+                    sb.append(file.toString());
+                    sb.append("\n"); // XXX platform
+                    for (int i = 0; i < list.length; i++) {
+                        sb.append("  ");
+                        sb.append(list[i].toString());
+                        sb.append("\n"); // XXX platform
+                    }
+                    System.err.println(sb.toString());
+                }
+            }
+        }
+    }
+
+    public void testAllJunitTests() {
+      checkBuild("run-all-junit-tests");
+    }
+
+	public void testBuild() {
+        checkBuild("build", 
+            Checklics.class.getName(), 
+            new String[0], // help message
+            true); // ant needed
+    }
+    
+    public void testUtil() {
+        checkBuild("util");
+    }
+
+    public void testAsm() {
+        checkBuild("asm");
+    }
+    
+    public void testRuntime() {
+        checkBuild("runtime");
+    }
+
+    public void testAspectj5rt() {
+        checkBuild("aspectj5rt"); 
+    }
+   
+//    public void testLocalOutOfDate() { 
+//        Messager handler = new Messager();
+//        File jarDir = new File("c:/home/ws/head/aj-build/jars");
+//        File baseDir = new File("c:/home/ws/head");
+//        Modules mods = new Modules(baseDir, jarDir, handler);
+//        Module module = mods.getModule("ajbrowser");
+//        Result r = module.getResult(Result.kind(true, true));
+//        r.outOfDate();
+//    }
+//    public void testAspectj5rtRequired() {
+//        File baseDir = new File("..");        
+//        Modules modules = new Modules(baseDir, getJarDir(), new Messager());
+//        Module module = modules.getModule("aspectj5rt");
+//        Result result = module.getResult(Result.kind(true, true));
+//        Result[] results = result.getRequired();
+//        System.out.println(result.toLongString());
+//        System.out.println("results: " + Arrays.asList(results));
+//        deleteTempFiles();
+//    }
+    public void testNoDuplicates() {
+        File weaverAllJar = null;
+        try {
+            weaverAllJar = doTask("weaver",true, true, true);
+        } catch (Throwable t) {
+            System.err.println(getClass() + ".testNoDuplicates() incomplete");
+            t.printStackTrace(System.err);
+            return;
+        }
+        String dupError = duplicateEntryError(weaverAllJar);
+        weaverAllJar.delete();
+        if (null != dupError) {
+            fail(dupError);
+        }
+    }
+    public void testAjbrowser() {
+        checkBuild("ajbrowser", 
+            "org.aspectj.tools.ajbrowser.Main",
+            new String[] {"-noExit", "-version"}); // compiler version
+    }
+    public void testTestingUtils() {
+        checkBuild("testing-util"); 
+    }
+
+    public void testAjdt() {
+        checkBuild("org.aspectj.ajdt.core", 
+           "org.aspectj.tools.ajc.Main",
+            new String[] { "-noExit", "-version" });
+    }//
+    public void testTesting() {
+        checkBuild("testing", 
+            "org.aspectj.testing.util.LangUtilTest", 
+            new String[] {"ignored"});
+    }
+    public void testTestingDrivers() {
+        checkBuild("testing-drivers", 
+            "org.aspectj.testing.drivers.Harness", 
+            new String[] {"-help"});
+    }
+    public void testWeaver() {
+        checkBuild("weaver"); 
+    }
+    
+    // ajdoc relies on tools.jar
+    public void testAspectjtools() {
+        if (!shouldBuild("aspectjtools")) {
+            return;
+        }
+        File baseDir = new File("..");
+        File tempBuildDir = new File(baseDir, "aj-build");
+        File distDir = new File(tempBuildDir, "dist");
+        File jarDir = new File(tempBuildDir, "jars");
+        assertTrue(distDir.canWrite() || distDir.mkdirs());
+        File productDir = new File(baseDir.getPath() + "/build/products/tools");
+        assertTrue(""+productDir, productDir.canRead());
+        checkBuildProduct(productDir, baseDir, distDir, jarDir);
+    }
+
+    void checkBuildProduct(File productDir, File baseDir, File distDir, File jarDir) {
+        if (!shouldBuild(productDir.getPath())) {
+            return;
+        }
+        assertTrue(null != productDir);
+        assertTrue(productDir.canRead());
+
+        checkJavac();
+
+        BuildModule task = new BuildModule();
+        Project project = new Project();
+        task.setProject(project);
+        assertTrue(jarDir.canWrite() || jarDir.mkdirs());
+        tempFiles.add(jarDir);
+        task.setJardir(new Path(project, jarDir.getAbsolutePath()));
+        task.setProductdir(new Path(project, productDir.getAbsolutePath()));
+        task.setBasedir(new Path(project, baseDir.getAbsolutePath()));
+        task.setDistdir(new Path(project, distDir.getAbsolutePath()));
+        task.setFailonerror(true);
+        if (null != BUILD_CONFIG) {
+            task.setBuildConfig(BUILD_CONFIG);
+        }
+        //task.setVerbose(true);
+        task.setCreateinstaller(true);
+        task.execute();
+        // now run installer and do product tests?
+    }
+
+    File getAntJar() {
+        return new File("../lib/ant/lib/ant.jar");
+    }
+    File getJUnitJar() {
+        return new File("../lib/junit/junit.jar");
+    }
+    
+    File getJarDir() {
+        if (null == jarDir) {
+            File baseDir = new File("../aj-build/");
+            if (!baseDir.canWrite()) {
+                baseDir = new File(".");
+            }
+            jarDir = new File(baseDir, "BuildModuleTest-jars");
+            tempFiles.add(jarDir);
+        }
+        if (!jarDir.exists()) {
+            assertTrue(jarDir.mkdirs());
+        }
+        return jarDir;
+    }
+    
+    BuildModule getTask(String module) {
+        BuildModule task = new BuildModule();
+        Project project = new Project();
+        task.setProject(project);
+        File jarDir = getJarDir();
+        assertTrue(jarDir.canWrite() || jarDir.mkdirs());
+        tempFiles.add(jarDir);
+        File moduleDir = new File(Util.path("..", module));
+        assertTrue(moduleDir.canRead());
+        task.setModuledir(new Path(project, moduleDir.getAbsolutePath()));
+        task.setJardir(new Path(project, jarDir.getAbsolutePath()));
+        task.setFailonerror(true);
+        if (null != BUILD_CONFIG) {
+            task.setBuildConfig(BUILD_CONFIG);
+        }
+        return task;
+    }
+    
+    void checkBuild(String module) { 
+        checkBuild(module, null, null, false);
+    }
+    
+    void checkBuild(String module, 
+        String classname, 
+        String[] args) {
+        checkBuild(module, classname, args, true);
+    }
+
+    boolean shouldBuild(String target) {
+        if (null == target) {
+            return false;
+        }
+        if (!building && !printedMessage) {
+            System.err.println(SKIP_MESSAGE + target + " (this is the only warning)");
+            printedMessage = true;
+        }
+        if (debugging()) {
+            for (int i = 0; i < DEBUGS.length; i++) {
+                if (target.equals(DEBUGS[i])) {
+                    return true;
+                }
+            }
+            return false;
+        } else {
+            for (int i = 0; i < SKIPS.length; i++) {
+                if (SKIPS[i].equals(target)) {
+                    if (printInfoMessages) {
+                        System.err.println(target + " skipped build test [" + getClass().getName() + ".shouldBuild(..)]");                
+                    }
+                    return false;
+                }
+            }
+        }
+        return building;
+    }
+    private static boolean debugging() {
+        return ((null != DEBUGS) && (0 < DEBUGS.length));
+    }
+    private static String duplicateEntryError(File weaverAllJar) {
+        ZipFile zipFile = null;
+        try {
+            zipFile = new ZipFile(weaverAllJar);
+            Enumeration e = zipFile.entries();
+            ArrayList<String> entryNames = new ArrayList<String>();
+            while (e.hasMoreElements()) {
+                ZipEntry entry = (ZipEntry) e.nextElement();
+                String name = entry.getName();
+                if (entryNames.contains(name)) {
+                    return "duplicate entry: " + name;
+                }
+                entryNames.add(name);
+            }
+        } catch (ZipException e) {
+            return "ZipException " + e;
+        } catch (IOException e) {
+            return "IOException " + e;
+        } finally {
+            if (null != zipFile) {
+                try {
+                    zipFile.close();
+                } catch (IOException e) {
+                    return "IOException closing " + zipFile + ": " + e;
+                }
+            }
+        }
+        return null;
+    }
+    
+    private static String name(String module, boolean trimTesting, boolean assemble) {
+        return module + (trimTesting?"":"-test") + (assemble?"-all":"");
+    }
+    private void deleteJar(File jar) {
+        if (!deleteJars) {
+            return ;
+        }
+        if (jar.exists()) {
+            jar.delete();
+        }
+        if (jar.exists()) {
+            try {
+                Thread.sleep(5000);
+            } catch (Throwable t) {                
+            }
+        }
+        if (jar.exists()) {
+            assertTrue("cannot delete " + jar, jar.delete());
+        }
+    }
+    void checkBuild(String module, 
+        String classname, 
+        String[] args,
+        boolean addAnt) {
+        if (!shouldBuild(module)) {
+            return;
+        }
+        assertTrue(null != module);
+        checkJavac();
+        doTask(module, true, false);
+        doTask(module, true, true);
+        doTask(module, false, false);
+        File jar = doTask(module, false, true, true);
+
+        // verify if possible
+        if (null != classname) {
+            Java java = new Java();
+            Project project = new Project();
+            java.setProject(project);
+            java.setFailonerror(true);
+            Path cp = new Path(project);
+            assertTrue(jar.canRead());
+            cp.append(new Path(project, jar.getAbsolutePath()));
+            if (addAnt) {
+                cp.append(new Path(project, getAntJar().getAbsolutePath()));
+                cp.append(new Path(project, getJUnitJar().getAbsolutePath()));
+            }
+            java.setClasspath(cp);
+            java.setClassname(classname);
+            if (null != args) {
+                for (int i = 0; i < args.length; i++) {
+                    Argument arg = java.createArg();
+                    arg.setValue(args[i]);
+                }
+            }
+            try {
+                java.execute();
+            } catch (BuildException e) {
+                e.printStackTrace(System.err);
+                assertTrue("BuildException running " + classname, false);
+            }
+        }
+        deleteJar(jar);        
+    }
+    void doTask(String module, boolean trimTesting, boolean assembleAll) {
+        doTask(module, trimTesting, assembleAll, false);
+    }
+
+    File doTask(String module, boolean trimTesting, boolean assembleAll, boolean keepJars) {
+        BuildModule task = getTask(module);
+        String name = name(module, trimTesting, assembleAll);
+        File jar = new File(getJarDir(), name+ ".jar");
+        task.setAssembleall(assembleAll);
+        task.setTrimtesting(trimTesting);
+        task.execute();
+        if (!jar.canRead()) {
+            File[] files = getJarDir().listFiles();
+            fail("cannot read " + jar + " in " + Arrays.asList(files));
+        }
+        if (!keepJars && deleteJars) {
+            deleteTempFiles();
+        }
+        return jar;
+    }
+
+    void checkJavac() {
+        boolean result = false;
+        try {
+            result = (null != Class.forName("sun.tools.javac.Main"));
+        } catch (Throwable t) {
+            // ignore
+        }
+        if (! result) {
+            assertTrue("add tools.jar to the classpath for Ant's use of javac", false);
+        }
+    }
+
+}
diff --git a/build/src/test/java/org/aspectj/internal/build/ModulesTest.java b/build/src/test/java/org/aspectj/internal/build/ModulesTest.java
new file mode 100644
index 000000000..16786404c
--- /dev/null
+++ b/build/src/test/java/org/aspectj/internal/build/ModulesTest.java
@@ -0,0 +1,304 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC),
+ *               2005-2006 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ *     Wes Isberg     build tests
+ * ******************************************************************/
+
+package org.aspectj.internal.build;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+import org.apache.tools.ant.BuildEvent;
+import org.apache.tools.ant.BuildListener;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.Task;
+import org.apache.tools.ant.types.Path;
+import org.aspectj.internal.tools.ant.taskdefs.AntBuilder;
+import org.aspectj.internal.tools.ant.taskdefs.BuildModule;
+import org.aspectj.internal.tools.build.Messager;
+import org.aspectj.internal.tools.build.Module;
+import org.aspectj.internal.tools.build.Modules;
+import org.aspectj.internal.tools.build.Result;
+import org.aspectj.internal.tools.build.Util;
+import org.aspectj.internal.tools.build.Result.Kind;
+/**
+ * 
+ */
+public class ModulesTest extends TestCase {
+    public static final List<String> MODULE_NAMES;
+    private static final File BASE_DIR = new File("..");
+    static {
+        String[] names = {
+        "ajbrowser", "ajde", "ajdoc", "asm", "aspectj5rt",
+        "bridge", "loadtime", "loadtime5", "org.aspectj.ajdt.core",
+        "runtime", "taskdefs", "testing-client", "testing-util",
+        "tests", "util", "weaver"};
+        List<String> list = Arrays.asList(names);
+        MODULE_NAMES = Collections.unmodifiableList(list);
+    }
+
+   private static boolean delete(File file) { // XXX Util
+        if ((null == file) || !file.exists()) {
+            return true;
+        }
+        if (file.isFile()) {
+            return file.delete();
+        } else {
+            File[] files = file.listFiles();
+            boolean result = true;
+            for (int i = 0; i < files.length; i++) {
+                if (!ModulesTest.delete(files[i])
+                    && result) {
+                    result = false;
+                }
+            }
+            return (file.delete() && result);
+        }
+    }
+
+    ArrayList<File> tempFiles = new ArrayList<File>();
+     
+	public ModulesTest(String name) {
+		super(name);
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+        for (Iterator<File> iter = tempFiles.iterator(); iter.hasNext();) {
+			File file = (File) iter.next();
+            if (!ModulesTest.delete(file)) {
+                System.err.println("warning: ModulesTest unable to delete " + file);
+            }
+		}
+	}
+    Modules getModules(Messager handler) {
+        File jarDir = new File("../aj-build-test-jars");
+        if (!jarDir.exists()) {
+            assertTrue(jarDir.mkdirs());
+            tempFiles.add(jarDir);
+        }
+        File baseDir = new File("..");
+        if (null == handler) {
+            handler = new Messager();
+        }
+        return new Modules(baseDir, jarDir, handler);
+    }
+      
+    public void testAllModulesCreation() {
+        ArrayList<Module> badModules = new ArrayList<Module>();
+        for (String name: MODULE_NAMES) {
+            File dir = new File(BASE_DIR, name);
+            if (dir.isDirectory()) {
+                File classpath = new File(dir, ".classpath");
+                if (classpath.exists()) {
+                    Modules modules = getModules(null);
+                    Module module = modules.getModule(name);
+                    if (!module.valid) {
+                        badModules.add(module);
+                    }
+                }
+            }
+        }
+        if (!badModules.isEmpty()) {
+            StringBuffer sb = new StringBuffer();
+            for (Module module: badModules) {
+                System.err.println(module.toLongString());
+                sb.append("\n");
+                sb.append(module);
+            }
+            fail(sb.toString());
+        }
+    }
+    
+    void checkModule(String s) {
+        if ("docs".equals(s) || "lib".equals(s)) {
+            return;
+        }
+        Modules modules = getModules(null);
+        Module module = modules.getModule(s);
+        if (!module.valid) {
+            assertTrue(module.toLongString(), false);
+        }
+    }
+    
+    public void testClasspathCreation() {
+        Modules modules = getModules(null);
+        Module ajdt = modules.getModule("org.aspectj.ajdt.core");
+        assertTrue(ajdt.valid);
+        
+        Project project = new Project();
+        AntBuilder builder = getBuilder(project);
+        Path classpath = new Path(project);
+        Kind kind = Result.kind(Result.NORMAL, !Result.ASSEMBLE);
+        Result result = ajdt.getResult(kind);
+        boolean hasLibraries = builder.setupClasspath(result, classpath);
+        assertTrue(hasLibraries);
+        if ((null == classpath) || (2 > classpath.size())) {
+            assertTrue(classpath.toString(), false);
+        }
+    }
+    
+    /**
+     * This test requires two OSGI modules:
+     * org.aspectj.util, which optionally depends on tempaspectjrt.
+     * Currently, the Ant builder does not handle linked source folders,
+     * and the OSGI support does not work around optional plugins.
+     */
+    public void skip_testOSGIModuleCreation() {
+        final String MODULE = "org.aspectj.util";
+        final String USES_MODULE = "tempaspectjrt";
+        
+        Modules modules = getModules(null);
+        Module newutil = modules.getModule(MODULE);
+        assertTrue(newutil.valid);
+        
+        Project project = new Project();
+        AntBuilder builder = getBuilder(project);
+        Path classpath = new Path(project);
+        Kind kind = Result.kind(Result.NORMAL, !Result.ASSEMBLE);
+        Result result = newutil.getResult(kind);
+        builder.setupClasspath(result, classpath);
+        System.out.println(newutil + " classpath: " + classpath);
+        if ((1 != classpath.size())) {
+            assertTrue(classpath.toString(), false);
+        }
+        String cpEntry = classpath.list()[0];
+        if (!cpEntry.endsWith(USES_MODULE + ".jar")) {
+            fail("expected " + classpath + " to end with " + USES_MODULE + ".jar");
+        }
+    }
+
+    private AntBuilder getBuilder(Project project) {
+        project.setBaseDir(new File("."));
+        project.setName("testOSGIModuleCreation");
+        File tempDir = new File(".");
+        return (AntBuilder) AntBuilder.getBuilder("", project, tempDir);        
+    }
+    
+    
+    /*********************************************************************
+     * The following tests/code enable you to run the entire build in JUnit
+     * to debug directly from Eclipse.  To compile using Javac, you will
+     * need to add tools.jar to the run classpath.
+     */
+    public void skip_testBuildingAspectJModule() {
+        final String moduleName = "org.aspectj.lib";
+        
+        File modulesDir = new File("..").getAbsoluteFile();
+        File buildDir = new File(modulesDir, "aj-build");
+        File distDir = new File(buildDir, "dist");
+        File jarDir = new File(buildDir, "jars");
+        File moduleDir = new File(modulesDir, moduleName);
+        File jar = new File(jarDir, "org.aspectj.lib.jar");
+        jarDir.mkdirs();
+        distDir.mkdirs();
+        if (jar.canRead()) {
+            assertTrue(jar.delete());
+        }
+        Project project = new Project();
+        project.setBaseDir(modulesDir);
+        project.setName("testAspectjbuild");
+        
+        BuildModule bm = new BuildModule();
+        bm.setProject(project);
+        bm.setAssembleall(true);
+        bm.setBuildConfig("");
+        bm.setModule(moduleName);
+        bm.setBasedir(new Path(project, modulesDir.getPath()));
+        bm.setDistdir(new Path(project, buildDir.getPath()));
+        bm.setJardir(new Path(project, jarDir.getPath()));
+        bm.setModuledir(new Path(project, moduleDir.getPath()));
+        bm.setTrimtesting(true);
+        bm.setBuildConfig("");
+        bm.setVersion("1.2");
+        bm.setVerbose(true);
+        bm.setFailonerror(true);
+        
+        bm.execute();
+        
+        assertTrue(jar.canRead());
+    }
+    
+    public void skip_testBuildingProduct() {
+        final String productName = "tools";
+        File modulesDir = new File("..").getAbsoluteFile();
+        File buildDir = new File(modulesDir, "aj-build");
+        File distDir = new File(buildDir, "dist");
+        File jarDir = new File(buildDir, "jars");
+        File productDir = new File(modulesDir, 
+                Util.path(new String[] {"build", "products", productName}));
+
+        jarDir.mkdirs();
+        distDir.mkdirs();
+
+        Project project = new Project();
+        project.setBaseDir(modulesDir);
+        project.setName("testAspectjToolsbuild");
+        project.addBuildListener(new EventBuildListener(Project.MSG_WARN));
+        
+        BuildModule bm = new BuildModule();
+        bm.setProject(project);
+        bm.setAssembleall(true);
+        bm.setBuildConfig("");
+        bm.setProductdir(new Path(project, productDir.getPath()));
+        bm.setBasedir(new Path(project, modulesDir.getPath()));
+        bm.setDistdir(new Path(project, distDir.getPath()));
+        bm.setJardir(new Path(project, jarDir.getPath()));
+        bm.setTrimtesting(true);
+        bm.setBuildConfig("");
+        bm.setVersion("1.2");
+        bm.setFailonerror(true);
+        bm.execute();
+        
+        File libDir = new File(distDir, "tools/lib");
+        String[] jars = { "tools", "rt", "weaver", "lib"};
+        for (int i = 0; i < jars.length; i++) {
+            File jar = new File(libDir, "aspectj" + jars[i] + ".jar");
+            assertTrue(jar.getPath(), jar.canRead()); 
+            if (10 > jar.length()) {
+                assertTrue(jar + " too small", false);
+            }
+        }
+    }
+    /**
+     * Show messages from the task.
+     * (normally shown by Ant's default listener)
+     */
+    static class EventBuildListener implements BuildListener {
+        final int min;
+        EventBuildListener(int min) {
+            this.min = min;
+        }
+        public void buildFinished(BuildEvent event) {}
+        public void buildStarted(BuildEvent event) {  }
+        public void messageLogged(BuildEvent event) { 
+            if (min <= event.getPriority()) {
+                Task t = event.getTask();
+                String src = (null == t ? "project" : t.getTaskName());
+                System.out.println(src + ": " + 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/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.01.MF b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.01.MF
new file mode 100644
index 000000000..e3ba88396
--- /dev/null
+++ b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.01.MF
@@ -0,0 +1,8 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Client Plug-in
+Bundle-SymbolicName: org.aspectj.testing.client
+Bundle-Version: 1.0.0
+Bundle-Localization: plugin
+Bundle-ClassPath: lib/commons/commons.jar
+
diff --git a/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.02.MF b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.02.MF
new file mode 100644
index 000000000..5888ab3c0
--- /dev/null
+++ b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.02.MF
@@ -0,0 +1,9 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Client Plug-in
+Bundle-SymbolicName: org.aspectj.testing.client
+Bundle-Version: 1.0.0
+Bundle-Localization: plugin
+Bundle-ClassPath: lib/commons/commons.jar, lib/ant/lib/ant.jar
+Require-Bundle: util, org.aspectj.runtime
+
diff --git a/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.03.MF b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.03.MF
new file mode 100644
index 000000000..b9717c5f2
--- /dev/null
+++ b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.03.MF
@@ -0,0 +1,9 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Client Plug-in
+Bundle-SymbolicName: org.aspectj.testing.client
+Bundle-Version: 1.0.0
+Bundle-Localization: plugin
+Bundle-ClassPath: lib/commons/commons.jar, lib/ant/lib/ant.jar
+Require-Bundle: util, aspectjrt;bundle-version="[1.5.0,1.5.5]";resolution:=optional
+
diff --git a/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.java b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.java
new file mode 100644
index 000000000..4926d42e8
--- /dev/null
+++ b/build/src/test/java/org/aspectj/internal/tools/build/UtilsTest.java
@@ -0,0 +1,200 @@
+/* *******************************************************************
+ * Copyright (c) 2006 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://eclipse.org/legal/epl-v10.html 
+ *  
+ * Contributors: 
+ *     Wes Isberg       initial implementation 
+ * ******************************************************************/
+
+package org.aspectj.internal.tools.build;
+
+import java.io.IOException;
+import java.util.jar.Attributes.Name;
+
+import junit.framework.TestCase;
+
+import org.aspectj.internal.tools.build.Util.OSGIBundle;
+import org.aspectj.internal.tools.build.Util.OSGIBundle.RequiredBundle;
+
+public class UtilsTest extends TestCase {
+    private static final String PREFIX = UtilsTest.class.getName().replace('.',
+            '/');
+
+    private static final ClassLoader LOADER = UtilsTest.class.getClassLoader();
+
+    private static final ManifestTest[] TESTS = {
+            new ManifestTest("01",
+                    new Name[] { OSGIBundle.BUNDLE_CLASSPATH,
+                            OSGIBundle.BUNDLE_SYMBOLIC_NAME,
+                            OSGIBundle.BUNDLE_VERSION }, new String[] {
+                            "lib/commons/commons.jar",
+                            "org.aspectj.testing.client", "1.0.0" }),
+            new ManifestTest("02",
+                    new Name[] { OSGIBundle.BUNDLE_SYMBOLIC_NAME,
+                            OSGIBundle.BUNDLE_VERSION }, new String[] {
+                            "org.aspectj.testing.client", "1.0.0" },
+                    new String[] { "lib/commons/commons.jar",
+                            "lib/ant/lib/ant.jar" }, new String[] { "util",
+                            "org.aspectj.runtime" }),
+            new ManifestTest("03",
+                    new Name[] { OSGIBundle.BUNDLE_SYMBOLIC_NAME,
+                            OSGIBundle.BUNDLE_VERSION }, new String[] {
+                            "org.aspectj.testing.client", "1.0.0" },
+                    new String[] { "lib/commons/commons.jar",
+                            "lib/ant/lib/ant.jar" }, new String[] { "util",
+                            "aspectjrt" }) {
+                void checkOthers(OSGIBundle osgiBundle, StringBuffer sb) {
+                    RequiredBundle[] bundles = osgiBundle.getRequiredBundles();
+                    for (int i = 0; i < bundles.length; i++) {
+                        RequiredBundle bundle = bundles[i];
+                        if ("aspectjrt".equals(bundle.name)) {
+                            if (!bundle.optional) {
+                                sb
+                                        .append("expected required bundle aspectjrt to be optional");
+                            }
+                            String version = "[1.5.0,1.5.5]";
+                            if (!(version.equals(bundle.versions))) {
+                                sb.append("expected version " + version
+                                        + " got " + bundle.versions
+                                        + " for required bundle aspectjrt");
+                            }
+                        }
+                    }
+
+                }
+            } };
+
+    private static class ManifestTest {
+        final String name;
+
+        final Name[] expectedNames;
+
+        final String[] expectedValues;
+
+        final String[] classpathEntries;
+
+        final String[] requiredBundleNames;
+
+        ManifestTest(String name, Name[] expectedNames, String[] expectedValues) {
+            this(name, expectedNames, expectedValues, null, null);
+        }
+
+        ManifestTest(String name, Name[] expectedNames,
+                String[] expectedValues, String[] classpathEntries,
+                String[] requiredBundleNames) {
+            this.name = name;
+            this.expectedNames = expectedNames;
+            this.expectedValues = expectedValues;
+            this.classpathEntries = classpathEntries;
+            this.requiredBundleNames = requiredBundleNames;
+        }
+
+        void run(StringBuffer sb) throws IOException {
+            String path = PREFIX + "." + name + ".MF";
+            OSGIBundle bundle = new OSGIBundle(LOADER.getResourceAsStream(path));
+            int len = sb.length();
+            checkNamesAndValues(bundle, sb);
+            checkOthers(bundle, sb);
+            if (sb.length() != len) {
+                sb.append("failure was in test " + name);
+            }
+        }
+
+        void checkOthers(OSGIBundle bundle, StringBuffer sb) {
+        }
+
+        void checkNamesAndValues(OSGIBundle bundle, StringBuffer sb) {
+            for (int i = 0; i < expectedNames.length; i++) {
+                Name name = expectedNames[i];
+                String expected = expectedValues[i];
+                String actual = bundle.getAttribute(expectedNames[i]);
+                if (!((expected == actual) || expected.equals(actual))) {
+                    sb.append(name);
+                    sb.append(" ");
+                    sb.append("expected ");
+                    sb.append(expected);
+                    sb.append("actual ");
+                    sb.append(actual);
+                    sb.append("\n");
+                }
+            }
+            if (null != classpathEntries) {
+                String[] cp = bundle.getClasspath();
+                Util.reportMemberDiffs(classpathEntries, cp, sb);
+            }
+            if (null != requiredBundleNames) {
+                RequiredBundle[] bundles = bundle.getRequiredBundles();
+                String[] names = new String[bundles.length];
+                for (int i = 0; i < names.length; i++) {
+                    names[i] = bundles[i].name;
+                }
+                Util.reportMemberDiffs(requiredBundleNames, names, sb);
+            }
+        }
+    }
+
+    /** disabled pending research */
+    public void skip_testOSGIManifests() throws Exception {
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < TESTS.length; i++) {
+            TESTS[i].run(sb);
+        }
+        if (0 < sb.length()) {
+            fail(sb.toString());
+        }
+    }
+
+    public void testReportMemberDiffs() {
+        StringBuffer sb = new StringBuffer();
+        String[] exp = null;
+        String[] act = null;
+        assertFalse(Util.reportMemberDiffs(exp, act, sb));
+        assertEquals("", sb.toString());
+
+        sb.setLength(0);
+        exp = new String[] { "" };
+        act = null;
+        assertTrue(Util.reportMemberDiffs(exp, act, sb));
+        assertEquals("unexpected [] missing [\"\"]", sb.toString());
+
+        sb.setLength(0);
+        exp = null;
+        act = new String[] { "" };
+        assertTrue(Util.reportMemberDiffs(exp, act, sb));
+        assertEquals("unexpected [\"\"] missing []", sb.toString());
+
+        sb.setLength(0);
+        exp = new String[] { "1", "2", "3" };
+        act = new String[] { "2", "4" };
+        assertTrue(Util.reportMemberDiffs(exp, act, sb));
+        assertEquals("unexpected [\"4\"] missing [\"1\", \"3\"]", sb.toString());
+
+    }
+    // public void testResourceStream() throws Exception {
+    // String path = PREFIX + ".one.mf";
+    // System.out.println(path);
+    // InputStream in = LOADER.getResourceAsStream(path);
+    // int i;
+    // while (-1 != (i = in.read())) {
+    // System.out.print((char) i);
+    // }
+    // System.out.println();
+    // }
+    // Map map = bundle.manifest.getEntries();
+    // for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
+    // MapEntry entry = (MapEntry) iter.next();
+    // System.out.println("entry: " + entry);
+    // }
+    // System.out.println("main attributes");
+    // Attributes attributes = bundle.manifest.getMainAttributes();
+    // Set keys = attributes.keySet();
+    // for (Iterator iter = keys.iterator(); iter.hasNext();) {
+    // Object key = iter.next();
+    // System.out.println(" key " + key);
+    // System.out.println(" value " + attributes.getValue(key.toString()));
+    // }
+}