java/java.freeform/test/unit/src/org/netbeans/modules/java/freeform/JavaActionsTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.netbeans.modules.java.freeform;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.modules.ant.freeform.FreeformProject;
import org.netbeans.modules.ant.freeform.TestBase;
import org.netbeans.modules.ant.freeform.spi.support.Util;
import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.AuxiliaryConfiguration;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;
import org.openide.xml.XMLUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Test how well JavaActions is working to generate targets.
 * @author Jesse Glick
 */
public class JavaActionsTest extends TestBase {
    
    static {
        // Simplify testing of stuff that can include localized messages.
        Locale.setDefault(Locale.US);
    }
    
    public JavaActionsTest(String name) {
        super(name);
    }
    
    private FreeformProject prj;
    private JavaActions ja;
    private FileObject src, myAppJava, someFileJava, someResourceTxt, antsrc, specialTaskJava, buildProperties;

    protected void setUp() throws Exception {
        super.setUp();
        prj = copyProject(simple);
        // Remove existing context-sensitive bindings to make a clean slate.
        Element data = prj.getPrimaryConfigurationData();
        Element ideActions = XMLUtil.findElement(data, "ide-actions", Util.NAMESPACE);
        assertNotNull(ideActions);
        Iterator<Element> actionsIt = XMLUtil.findSubElements(ideActions).iterator();
        while (actionsIt.hasNext()) {
            Element action = actionsIt.next();
            assertEquals("action", action.getLocalName());
            if (XMLUtil.findElement(action, "context", Util.NAMESPACE) != null) {
                ideActions.removeChild(action);
            }
        }
        prj.putPrimaryConfigurationData(data);
        ProjectManager.getDefault().saveProject(prj);
        AuxiliaryConfiguration origAux = prj.getLookup().lookup(AuxiliaryConfiguration.class);
        AuxiliaryConfiguration aux = new LookupProviderImpl.UpgradingAuxiliaryConfiguration(origAux);
        ja = new JavaActions(prj, prj.helper(), prj.evaluator(), aux);
        src = prj.getProjectDirectory().getFileObject("src");
        assertNotNull(src);
        myAppJava = src.getFileObject("org/foo/myapp/MyApp.java");
        assertNotNull(myAppJava);
        someFileJava = src.getFileObject("org/foo/myapp/SomeFile.java");
        assertNotNull(someFileJava);
        someResourceTxt = src.getFileObject("org/foo/myapp/some-resource.txt");
        assertNotNull(someResourceTxt);
        antsrc = prj.getProjectDirectory().getFileObject("antsrc");
        assertNotNull(antsrc);
        specialTaskJava = antsrc.getFileObject("org/foo/ant/SpecialTask.java");
        assertNotNull(specialTaskJava);
        buildProperties = prj.getProjectDirectory().getFileObject("build.properties");
        assertNotNull(buildProperties);
    }
    
    public void testContainsSelectedJavaSources() throws Exception {
        assertTrue(ja.containsSelectedJavaSources(src, contextDO(new FileObject[] {myAppJava})));
        assertFalse(ja.containsSelectedJavaSources(src, contextDO(new FileObject[] {myAppJava, someResourceTxt})));
    }
    
    public void testFindPackageRoot() throws Exception {
        Lookup context = contextDO(new FileObject[] {myAppJava});
        JavaActions.AntLocation loc = ja.findPackageRoot(context);
        assertNotNull("found a package root for " + context, loc);
        assertEquals("right name", "${src.dir}", loc.virtual);
        assertEquals("right physical", src, loc.physical);
        context = contextDO(new FileObject[] {myAppJava, someFileJava});
        loc = ja.findPackageRoot(context);
        assertNotNull("found a package root for " + context, loc);
        assertEquals("right name", "${src.dir}", loc.virtual);
        assertEquals("right physical", src, loc.physical);
        context = contextDO(new FileObject[] {src});
        loc = ja.findPackageRoot(context);
        assertNotNull("found a package root for " + context, loc);
        assertEquals("right name", "${src.dir}", loc.virtual);
        assertEquals("right physical", src, loc.physical);
        context = contextDO(new FileObject[] {myAppJava, someResourceTxt});
        loc = ja.findPackageRoot(context);
        assertNull("found no package root for " + context + ": " + loc, loc);
        context = contextDO(new FileObject[] {myAppJava, specialTaskJava});
        loc = ja.findPackageRoot(context);
        assertNull("found no package root for " + context, loc);
        context = contextDO(new FileObject[] {});
        loc = ja.findPackageRoot(context);
        assertNull("found no package root for " + context, loc);
        context = contextDO(new FileObject[] {specialTaskJava});
        loc = ja.findPackageRoot(context);
        assertNotNull("found a package root for " + context, loc);
        assertEquals("right name", "${ant.src.dir}", loc.virtual);
        assertEquals("right physical", antsrc, loc.physical);
        context = contextDO(new FileObject[] {buildProperties});
        loc = ja.findPackageRoot(context);
        assertNull("found no package root for " + context, loc);
    }
    
    public void testGetSupportedActions() throws Exception {
        assertEquals("initially all context-sensitive actions supported",
            Arrays.asList(new String[] {
                ActionProvider.COMMAND_COMPILE_SINGLE,
                ActionProvider.COMMAND_DEBUG,
                ActionProvider.COMMAND_PROFILE,
                ActionProvider.COMMAND_RUN_SINGLE,
                ActionProvider.COMMAND_DEBUG_SINGLE,
                ActionProvider.COMMAND_PROFILE_SINGLE
            }),
            Arrays.asList(ja.getSupportedActions()));
        /* Not really necessary; once there is a binding, the main ant/freeform Actions will mask this anyway:
        ja.addBinding(ActionProvider.COMMAND_COMPILE_SINGLE, "target", "prop", "${dir}", null, "relative-path", null);
        assertEquals("binding a context-sensitive action makes it not be supported any longer",
            Collections.EMPTY_LIST,
            Arrays.asList(ja.getSupportedActions()));
         */
    }
    
    public void testIsActionEnabled() throws Exception {
        assertTrue("enabled on some source files", ja.isActionEnabled(ActionProvider.COMMAND_COMPILE_SINGLE, context(new FileObject[] {myAppJava, someFileJava})));
        assertFalse("disabled on other stuff", ja.isActionEnabled(ActionProvider.COMMAND_COMPILE_SINGLE, context(new FileObject[] {buildProperties})));
    }
    
    private static boolean useDO = false; // exercise lookup of both FO and DO
    private Lookup context(FileObject[] files) throws Exception {
        Object[] objs = new Object[files.length];
        for (int i = 0; i < files.length; i++) {
            objs[i] = useDO ? (Object) DataObject.find(files[i]) : files[i];
            useDO = !useDO;
        }
        return Lookups.fixed(objs);
    }
    
    private Lookup contextDO(FileObject[] files) throws Exception {
        Object[] objs = new Object[files.length];
        for (int i = 0; i < files.length; i++) {
            objs[i] = (Object) DataObject.find(files[i]);
        }
        return Lookups.fixed(objs);
    }
    
    public void testFindClassesOutputDir() throws Exception {
        assertEquals("Output for src", "${classes.dir}", ja.findClassesOutputDir("${src.dir}"));
        assertEquals("Output for antsrc", "${ant.classes.dir}", ja.findClassesOutputDir("${ant.src.dir}"));
        assertEquals("No output for bogussrc", null, ja.findClassesOutputDir("${bogus.src.dir}"));
    }
    
    public void testAddBinding() throws Exception {
        ja.addBinding("some.action", "special.xml", "special-target", "selection", "${some.src.dir}", "\\.java$", "relative-path", ",");
        Element data = prj.getPrimaryConfigurationData();
        assertNotNull(data);
        Element ideActions = XMLUtil.findElement(data, "ide-actions", Util.NAMESPACE);
        assertNotNull(ideActions);
        List<Element> actions = XMLUtil.findSubElements(ideActions);
        Element lastAction = actions.get(actions.size() - 1);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<action xmlns=\"" + Util.NAMESPACE + "\" name=\"some.action\">\n" +
            "    <script>special.xml</script>\n" +
            "    <target>special-target</target>\n" +
            "    <context>\n" +
            "        <property>selection</property>\n" +
            "        <folder>${some.src.dir}</folder>\n" +
            "        <pattern>\\.java$</pattern>\n" +
            "        <format>relative-path</format>\n" +
            "        <arity>\n" +
            "            <separated-files>,</separated-files>\n" +
            "        </arity>\n" +
            "    </context>\n" +
            "</action>\n";
        assertEquals(expectedXml, xmlToString(lastAction));
        ja.addBinding("some.other.action", "special.xml", "special-target", "selection", "${some.src.dir}", null, "relative-path", null);
        data = prj.getPrimaryConfigurationData();
        ideActions = XMLUtil.findElement(data, "ide-actions", Util.NAMESPACE);
        actions = XMLUtil.findSubElements(ideActions);
        lastAction = actions.get(actions.size() - 1);
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<action xmlns=\"" + Util.NAMESPACE + "\" name=\"some.other.action\">\n" +
            "    <script>special.xml</script>\n" +
            "    <target>special-target</target>\n" +
            "    <context>\n" +
            "        <property>selection</property>\n" +
            "        <folder>${some.src.dir}</folder>\n" +
            "        <format>relative-path</format>\n" +
            "        <arity>\n" +
            "            <one-file-only/>\n" +
            "        </arity>\n" +
            "    </context>\n" +
            "</action>\n";
        assertEquals(expectedXml, xmlToString(lastAction));
        // Non-context-sensitive bindings have no <context> but need to add a view item.
        ja.addBinding("general.action", "special.xml", "special-target", null, null, null, null, null);
        data = prj.getPrimaryConfigurationData();
        ideActions = XMLUtil.findElement(data, "ide-actions", Util.NAMESPACE);
        actions = XMLUtil.findSubElements(ideActions);
        lastAction = actions.get(actions.size() - 1);
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<action xmlns=\"" + Util.NAMESPACE + "\" name=\"general.action\">\n" +
            "    <script>special.xml</script>\n" +
            "    <target>special-target</target>\n" +
            "</action>\n";
        assertEquals(expectedXml, xmlToString(lastAction));
        Element view = XMLUtil.findElement(data, "view", Util.NAMESPACE);
        assertNotNull(view);
        Element contextMenu = XMLUtil.findElement(view, "context-menu", Util.NAMESPACE);
        assertNotNull(contextMenu);
        // Currently (no FPG to help) it is always added as the last item.
        List<Element> contextMenuActions = XMLUtil.findSubElements(contextMenu);
        Element lastContextMenuAction = contextMenuActions.get(contextMenuActions.size() - 1);
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<ide-action xmlns=\"" + Util.NAMESPACE + "\" name=\"general.action\"/>\n";
        assertEquals(expectedXml, xmlToString(lastContextMenuAction));
        
        //test #58442:
        data = prj.getPrimaryConfigurationData();
        ideActions = XMLUtil.findElement(data, "ide-actions", Util.NAMESPACE);
        data.removeChild(ideActions);
        
        ja.addBinding("some.other.action", "special.xml", "special-target", "selection", "${some.src.dir}", null, "relative-path", null);
        data = prj.getPrimaryConfigurationData();
        ideActions = XMLUtil.findElement(data, "ide-actions", Util.NAMESPACE);
        actions = XMLUtil.findSubElements(ideActions);
        lastAction = actions.get(actions.size() - 1);
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<action xmlns=\"" + Util.NAMESPACE + "\" name=\"some.other.action\">\n" +
            "    <script>special.xml</script>\n" +
            "    <target>special-target</target>\n" +
            "    <context>\n" +
            "        <property>selection</property>\n" +
            "        <folder>${some.src.dir}</folder>\n" +
            "        <format>relative-path</format>\n" +
            "        <arity>\n" +
            "            <one-file-only/>\n" +
            "        </arity>\n" +
            "    </context>\n" +
            "</action>\n";
        assertEquals(expectedXml, xmlToString(lastAction));
    }
    
    public void testCreateCompileSingleTarget() throws Exception {
        Document doc = XMLUtil.createDocument("fake", null, null, null);
        Lookup context = context(new FileObject[] {someFileJava});
        Element target = ja.createCompileSingleTarget(doc, context, "files", new JavaActions.AntLocation("${src.dir}", src));
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<target name=\"compile-selected-files-in-src\">\n" +
            "    <fail unless=\"files\">Must set property 'files'</fail>\n" +
            "    <mkdir dir=\"${classes.dir}\"/>\n" +
            "    <javac destdir=\"${classes.dir}\" includes=\"${files}\" source=\"1.4\" srcdir=\"${src.dir}\">\n" +
            "        <classpath path=\"${src.cp}\"/>\n" +
            "    </javac>\n" +
            "</target>\n";
        assertEquals(expectedXml, xmlToString(target));
    }
    
    public void testReadWriteCustomScript() throws Exception {
        Document script = ja.readCustomScript(JavaActions.FILE_SCRIPT_PATH);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project name=\"Simple Freeform Project-IDE\"/>\n";
        assertEquals(expectedXml, xmlToString(script.getDocumentElement()));
        script.getDocumentElement().appendChild(script.createElement("foo"));
        ja.writeCustomScript(script, JavaActions.FILE_SCRIPT_PATH);
        script = ja.readCustomScript(JavaActions.FILE_SCRIPT_PATH);
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project name=\"Simple Freeform Project-IDE\">\n" +
            "    <foo/>\n" +
            "</project>\n";
        assertEquals(expectedXml, xmlToString(script.getDocumentElement()));
    }
    
    public void testFindSourceLevel() throws Exception {
        assertEquals("1.4", ja.findSourceLevel("${src.dir}"));
        assertEquals("1.4", ja.findSourceLevel("${ant.src.dir}"));
        assertEquals(null, ja.findSourceLevel("${bogus.src.dir}"));
    }
    
    public void testFindCompileClasspath() throws Exception {
        assertEquals("${src.cp}", ja.findCUClasspath("${src.dir}", "compile"));
        assertEquals("${ant.src.cp}", ja.findCUClasspath("${ant.src.dir}", "compile"));
        assertEquals(null, ja.findCUClasspath("${bogus.src.dir}", "compile"));
    }
    
    public void testFindLine() throws Exception {
        Document script = ja.readCustomScript("special.xml");
        Element target = script.createElement("target");
        target.setAttribute("name", "targ1");
        target.appendChild(script.createElement("task1"));
        target.appendChild(script.createElement("task2"));
        script.getDocumentElement().appendChild(target);
        target = script.createElement("target");
        target.setAttribute("name", "targ2");
        target.appendChild(script.createElement("task3"));
        script.getDocumentElement().appendChild(target);
        ja.writeCustomScript(script, "special.xml");
        FileObject scriptFile = prj.getProjectDirectory().getFileObject("special.xml");
        assertNotNull(scriptFile);
        //0 <?xml?>
        //1 <project>
        //2     <target name="targ1">
        //3         <task1/>
        //4         <task2/>
        //5     </>
        //6     <target name="targ2">
        //7         <task3/>
        //8     </>
        //9 </>
        assertEquals(2, JavaActions.findLine(scriptFile, "targ1", "target", "name"));
        assertEquals(6, JavaActions.findLine(scriptFile, "targ2", "target", "name"));
        assertEquals(-1, JavaActions.findLine(scriptFile, "no-such-targ", "target", "name"));
        // Try w/ project.xml which uses namespaces, too.
        FileObject pxml = prj.getProjectDirectory().getFileObject("nbproject/project.xml");
        assertNotNull(pxml);
        assertTrue(JavaActions.findLine(pxml, "build", "action", "name") != -1);
        assertEquals(-1, JavaActions.findLine(pxml, "nonexistent", "action", "name"));
    }
    
    public void testFindCommandBinding() throws Exception {
        String[] binding = ja.findCommandBinding(ActionProvider.COMMAND_RUN);
        assertNotNull(binding);
        assertEquals(Arrays.asList(new String[] {"build.xml", "start"}), Arrays.asList(binding));
        binding = ja.findCommandBinding(ActionProvider.COMMAND_REBUILD);
        assertNotNull(binding);
        assertEquals(Arrays.asList(new String[] {"build.xml", "clean", "jar"}), Arrays.asList(binding));
        binding = ja.findCommandBinding("bogus");
        assertNull(binding);
    }
    
    public void testFindExistingBuildTarget() throws Exception {
        Element target = ja.findExistingBuildTarget(ActionProvider.COMMAND_RUN);
        assertNotNull("found a target for 'run'", target);
        assertEquals("found correct target", "start", target.getAttribute("name"));
    }
    
    public void testTargetUsesTaskExactlyOnce() throws Exception {
        Element runTarget = ja.findExistingBuildTarget(ActionProvider.COMMAND_RUN);
        Element javaTask = ja.targetUsesTaskExactlyOnce(runTarget, "java");
        assertNotNull("found <java>", javaTask);
        assertEquals("java", javaTask.getLocalName());
        assertEquals("org.foo.myapp.MyApp", javaTask.getAttribute("classname"));
        assertNull("no <javac> here", ja.targetUsesTaskExactlyOnce(runTarget, "javac"));
        Element cleanTarget = ja.findExistingBuildTarget(ActionProvider.COMMAND_CLEAN);
        assertNotNull(cleanTarget);
        assertNull(">1 <delete> found so skipping", ja.targetUsesTaskExactlyOnce(cleanTarget, "delete"));
    }
    
    public void testEnsurePropertiesCopied() throws Exception {
        Document doc = XMLUtil.createDocument("project", null, null, null);
        Element root = doc.getDocumentElement();
        ja.ensurePropertiesCopied(root);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project basedir=\"..\">\n" +
            "    <property name=\"build.properties\" value=\"build.properties\"/>\n" +
            "    <property file=\"${build.properties}\"/>\n" +
            "</project>\n";
        assertEquals("Correct code generated", expectedXml, xmlToString(root));
        ja.ensurePropertiesCopied(root);
        assertEquals("Idempotent", expectedXml, xmlToString(root));
    }
    
    public void testEnsureImports() throws Exception {
        // Start with the simple case:
        Element root = XMLUtil.createDocument("project", null, null, null).getDocumentElement();
        ja.ensureImports(root, "build.xml");
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project basedir=\"..\">\n" +
            "    <import file=\"../build.xml\"/>\n" +
            "</project>\n";
        assertEquals("Correct code generated", expectedXml, xmlToString(root));
        ja.ensureImports(root, "build.xml");
        assertEquals("Idempotent", expectedXml, xmlToString(root));
        // Test strange locations too. Make a script somewhere different.
        File testdir = getWorkDir();
        File subtestdir = new File(testdir, "sub");
        subtestdir.mkdir();
        File script = new File(subtestdir, "external.xml");
        Document doc = XMLUtil.createDocument("project", null, null, null);
        doc.getDocumentElement().setAttribute("basedir", "..");
        OutputStream os = new FileOutputStream(script);
        try {
            XMLUtil.write(doc, os, "UTF-8");
        } finally {
            os.close();
        }
        root = XMLUtil.createDocument("project", null, null, null).getDocumentElement();
        String scriptPath = script.getAbsolutePath();
        ja.ensureImports(root, scriptPath);
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project basedir=\"" + testdir.getAbsolutePath() + "\">\n" +
            "    <import file=\"" + scriptPath + "\"/>\n" +
            "</project>\n";
        assertEquals("Correct code generated for external script", expectedXml, xmlToString(root));
        // And also with locations defined as special properties in various ways...
        Element data = prj.getPrimaryConfigurationData();
        Element properties = XMLUtil.findElement(data, "properties", Util.NAMESPACE);
        assertNotNull(properties);
        Element property = data.getOwnerDocument().createElementNS(Util.NAMESPACE, "property");
        property.setAttribute("name", "external.xml");
        property.appendChild(data.getOwnerDocument().createTextNode(scriptPath));
        properties.appendChild(property);
        property = data.getOwnerDocument().createElementNS(Util.NAMESPACE, "property");
        property.setAttribute("name", "subtestdir");
        property.appendChild(data.getOwnerDocument().createTextNode(subtestdir.getAbsolutePath()));
        properties.appendChild(property);
        property = data.getOwnerDocument().createElementNS(Util.NAMESPACE, "property");
        property.setAttribute("name", "testdir");
        property.appendChild(data.getOwnerDocument().createTextNode(testdir.getAbsolutePath()));
        properties.appendChild(property);
        prj.putPrimaryConfigurationData(data);
        ProjectManager.getDefault().saveProject(prj); // ease of debugging
        root = XMLUtil.createDocument("project", null, null, null).getDocumentElement();
        ja.ensureImports(root, "${external.xml}");
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project basedir=\"" + testdir.getAbsolutePath() + "\">\n" +
            "    <import file=\"" + scriptPath +  "\"/>\n" +
            "</project>\n";
        assertEquals("Correct code generated for ${external.xml}", expectedXml, xmlToString(root));
        root = XMLUtil.createDocument("project", null, null, null).getDocumentElement();
        ja.ensureImports(root, "${subtestdir}" + File.separator + "external.xml");
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project basedir=\"" + testdir.getAbsolutePath() + "\">\n" +
            "    <import file=\"" + scriptPath +  "\"/>\n" +
            "</project>\n";
        assertEquals("Correct code generated for ${subtestdir}/external.xml", expectedXml, xmlToString(root));
        root = XMLUtil.createDocument("project", null, null, null).getDocumentElement();
        ja.ensureImports(root, "${testdir}" + File.separator + "sub" +File.separator + "external.xml");
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project basedir=\"" + testdir.getAbsolutePath() + "\">\n" +
            "    <import file=\"" + scriptPath +  "\"/>\n" +
            "</project>\n";
        assertEquals("Correct code generated for ${testdir}/sub/external.xml", expectedXml, xmlToString(root));
        // XXX try also <import file="somewhere-relative/build.xml"/>
    }
    
    public void testCreateDebugTargetFromTemplate() throws Exception {
        Document doc = XMLUtil.createDocument("project", null, null, null);
        Document origDoc = XMLUtil.createDocument("target", null, null, null);
        Element origTarget = origDoc.getDocumentElement();
        origTarget.setAttribute("name", "ignored");
        origTarget.setAttribute("depends", "compile");
        origTarget.appendChild(origDoc.createElement("task1"));
        Element task = origDoc.createElement("java");
        // XXX also test nested <classpath>:
        task.setAttribute("classpath", "${cp}");
        task.appendChild(origDoc.createElement("stuff"));
        origTarget.appendChild(task);
        origTarget.appendChild(origDoc.createElement("task2"));
        Element genTarget = ja.createDebugTargetFromTemplate("debug", origTarget, task, doc);
        doc.getDocumentElement().appendChild(genTarget);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project>\n" +
            "    <target depends=\"compile\" name=\"debug\">\n" +
            "        <task1/>\n" +
            "        <nbjpdastart addressproperty=\"jpda.address\" name=\"Simple Freeform Project\" transport=\"dt_socket\">\n" +
            "            <classpath path=\"${cp}\"/>\n" +
            "        </nbjpdastart>\n" +
            "        <java classpath=\"${cp}\" fork=\"true\">\n" +
            "            <stuff/>\n" +
            "            <jvmarg value=\"-agentlib:jdwp=transport=dt_socket,address=${jpda.address}\"/>\n" +
            "        </java>\n" +
            "        <task2/>\n" +
            "    </target>\n" +
            "</project>\n";
        assertEquals(expectedXml, xmlToString(doc.getDocumentElement()));
    }
    
    public void testCreateDebugTargetFromScratch() throws Exception {
        Document doc = XMLUtil.createDocument("project", null, null, null);
        Element genTarget = ja.createDebugTargetFromScratch("debug", doc);
        doc.getDocumentElement().appendChild(genTarget);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project>\n" +
            "    <target name=\"debug\">\n" +
            "        <path id=\"cp\">\n" +
            "            <!---->\n" +
            "        </path>\n" +
            "        <nbjpdastart addressproperty=\"jpda.address\" name=\"Simple Freeform Project\" transport=\"dt_socket\">\n" +
            "            <classpath refid=\"cp\"/>\n" +
            "        </nbjpdastart>\n" +
            "        <!---->\n" +
            "        <java classname=\"some.main.Class\" fork=\"true\">\n" +
            "            <classpath refid=\"cp\"/>\n" +
            "            <jvmarg value=\"-agentlib:jdwp=transport=dt_socket,address=${jpda.address}\"/>\n" +
            "        </java>\n" +
            "    </target>\n" +
            "</project>\n";
        assertEquals(expectedXml, xmlToString(doc.getDocumentElement()));
    }
    
    public void testCreateProfileTargetFromScratch() throws Exception {
        Document doc = XMLUtil.createDocument("project", null, null, null);
        Element genTarget = ja.createProfileTargetFromScratch("profile", doc);
        doc.getDocumentElement().appendChild(genTarget);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project>\n" +
            "    <target name=\"-profile-check\">\n" +
            "        <startprofiler freeform=\"true\"/>\n" +
            "    </target>\n" +
            "    <target depends=\"-profile-check\" if=\"profiler.configured\" name=\"profile\">\n" +
            "        <path id=\"cp\">\n" +
            "            <!---->\n" +
            "        </path>\n" +
            "        <!---->\n" +
            "        <java classname=\"some.main.Class\" fork=\"true\">\n" +
            "            <classpath refid=\"cp\"/>\n" +
            "            <jvmarg line=\"${agent.jvmargs}\"/>\n" +
            "        </java>\n" +
            "    </target>\n" +
            "</project>\n";
        assertEquals(expectedXml, xmlToString(doc.getDocumentElement()));
    }
    
    public void testCreateProfileTargetFromTemplate() throws Exception {
        Document doc = XMLUtil.createDocument("project", null, null, null);
        Document origDoc = XMLUtil.createDocument("target", null, null, null);
        Element origTarget = origDoc.getDocumentElement();
        origTarget.setAttribute("name", "ignored");
        origTarget.setAttribute("depends", "compile");
        origTarget.appendChild(origDoc.createElement("task1"));
        Element task = origDoc.createElement("java");
        // XXX also test nested <classpath>:
        task.setAttribute("classpath", "${cp}");
        task.appendChild(origDoc.createElement("stuff"));
        origTarget.appendChild(task);
        origTarget.appendChild(origDoc.createElement("task2"));
        Element genTarget = ja.createProfileTargetFromTemplate("profile", origTarget, task, doc);
        doc.getDocumentElement().appendChild(genTarget);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project>\n" +
            "    <target name=\"-profile-check\">\n" +
            "        <startprofiler freeform=\"true\"/>\n" +
            "    </target>\n" +
            "    <target depends=\"-profile-check\" if=\"profiler.configured\" name=\"profile\">\n" +
            "        <task1/>\n" +
            "        <java classpath=\"${cp}\" fork=\"true\">\n" +
            "            <stuff/>\n" +
            "            <jvmarg line=\"${agent.jvmargs}\"/>\n" +
            "        </java>\n" +
            "        <task2/>\n" +
            "    </target>\n" +
            "</project>\n";
        assertEquals(expectedXml, xmlToString(doc.getDocumentElement()));
    }

    public void testCreateRunSingleTargetElem() throws Exception {
        Document doc = XMLUtil.createDocument("project", null, null, null);
        Lookup context = contextDO(new FileObject[] {myAppJava});
        JavaActions.AntLocation root = ja.findPackageRoot(context);
        Element targetElem = ja.createRunSingleTargetElem(doc, "run-single-test-target", "test.class", root);
        doc.getDocumentElement().appendChild(targetElem);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project>\n" +
            "    <target name=\"run-single-test-target\">\n" +
            "        <fail unless=\"test.class\">Must set property 'test.class'</fail>\n" +
            "        <ant antfile=\"build.xml\" inheritall=\"false\" target=\"jar\"/>\n" +
            "        <java classname=\"${test.class}\" failonerror=\"true\" fork=\"true\">\n" +
            "            <classpath>\n" +
            "                <pathelement path=\"${src.cp}\"/>\n" +
            "                <pathelement location=\"${classes.dir}\"/>\n" +
            "                <pathelement location=\"${main.jar}\"/>\n" +
            "            </classpath>\n" +
            "        </java>\n" +
            "    </target>\n" +
            "</project>\n";
        assertEquals(expectedXml, xmlToString(doc.getDocumentElement()));
    }

    public void testCreateDebugSingleTargetElem() throws Exception {
        Document doc = XMLUtil.createDocument("project", null, null, null);
        Lookup context = contextDO(new FileObject[] {myAppJava});
        JavaActions.AntLocation root = ja.findPackageRoot(context);
        Element targetElem = ja.createDebugSingleTargetElem(doc, "debug-single-test-target", "test.class", root);
        doc.getDocumentElement().appendChild(targetElem);
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project>\n" +
            "    <target name=\"debug-single-test-target\">\n" +
            "        <fail unless=\"test.class\">Must set property 'test.class'</fail>\n" +
            "        <ant antfile=\"build.xml\" inheritall=\"false\" target=\"jar\"/>\n" +
            "        <path id=\"cp\">\n" +
            "            <pathelement path=\"${src.cp}\"/>\n" +
            "            <pathelement location=\"${classes.dir}\"/>\n" +
            "            <pathelement location=\"${main.jar}\"/>\n" +
            "        </path>\n" +
            "        <nbjpdastart addressproperty=\"jpda.address\" name=\"Simple Freeform Project\" transport=\"dt_socket\">\n" +
            "            <classpath refid=\"cp\"/>\n" +
            "        </nbjpdastart>\n" +
            "        <java classname=\"${test.class}\" fork=\"true\">\n" +
            "            <classpath refid=\"cp\"/>\n" +
            "            <jvmarg value=\"-agentlib:jdwp=transport=dt_socket,address=${jpda.address}\"/>\n" +
            "        </java>\n" +
            "    </target>\n" +
            "</project>\n";
        assertEquals(expectedXml, xmlToString(doc.getDocumentElement()));
    }

    public void testCreatePathLikeElem() throws Exception {
        Document doc = XMLUtil.createDocument("testdoc", null, null, null);
        Element pathElem = ja.createPathLikeElem(doc, "path", "id",
                new String[] {"lib/File.jar;lib/File2.jar", "testlib/Lib1.jar;testlib/Lib2"},
                new String[] {"c:\\workfiles\\library.jar", "/workfiles/library2.jar"},
                "refid", "comment");
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<path id=\"id\" refid=\"refid\">\n" +
            "    <!---->\n" +
            "    <pathelement path=\"lib/File.jar;lib/File2.jar\"/>\n" +
            "    <pathelement path=\"testlib/Lib1.jar;testlib/Lib2\"/>\n" +
            "    <pathelement location=\"c:\\workfiles\\library.jar\"/>\n" +
            "    <pathelement location=\"/workfiles/library2.jar\"/>\n" +
            "</path>\n";
        assertEquals(expectedXml, xmlToString(pathElem));
        pathElem = ja.createPathLikeElem(doc, "classpath", null, null, null, null, "comment");
        expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<classpath>\n" +
            "    <!---->\n" +
            "</classpath>\n";
        assertEquals(expectedXml, xmlToString(pathElem));
    }

    public void testCreateAntElem() throws Exception {
        Document doc = XMLUtil.createDocument("testdoc", null, null, null);
        Element antElem = ja.createAntElem(doc, "antscript.xml", "test.target");
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<ant antfile=\"antscript.xml\" inheritall=\"false\" target=\"test.target\"/>\n";
        assertEquals(expectedXml, xmlToString(antElem));
    }

    public void testGetPathFromCU() throws Exception {
        Document doc = XMLUtil.createDocument("testdoc", null, null, null);
        Lookup context = contextDO(new FileObject[] {myAppJava});
        JavaActions.AntLocation root = ja.findPackageRoot(context);
        Element cpElem = ja.getPathFromCU(doc, root.virtual, "classpath");
        String expectedXml =
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<classpath>\n" +
            "    <pathelement path=\"${src.cp}\"/>\n" +
            "    <pathelement location=\"${classes.dir}\"/>\n" +
            "    <pathelement location=\"${main.jar}\"/>\n" +
            "</classpath>\n";
        assertEquals(expectedXml, xmlToString(cpElem));
    }

    public void testGetRunDepends() throws Exception {
        String s[] = ja.getRunDepends();
        assertEquals("build.xml", s[0]);
        assertEquals("jar", s[1]);
    }

    /**
     * Format XML as a string. Assumes Xerces serializer in current impl.
     * Collapse all comments to no body.
     */
    private static String xmlToString(Element el) throws Exception {
        Document doc = XMLUtil.createDocument("fake", null, null, null);
        doc.removeChild(doc.getDocumentElement());
        doc.appendChild(doc.importNode(el, true));
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        XMLUtil.write(doc, baos, "UTF-8");
        return baos.toString("UTF-8").replaceAll("<!--([^-]|-[^-])*-->", "<!---->").replaceAll(System.getProperty("line.separator"), "\n");
    }
    
}