Attachment #94855 for bug #136595

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 136595
Collapse All | Expand All




        try {
            Document projectXml = loadProjectXml(projectDiskFile);
            if (projectXml != null) {
                Element typeEl = XMLUtil.findElement(projectXml.getDocumentElement(), "type", PROJECT_NS); // NOI18N
                if (typeEl != null) {
                    String type = XMLUtil.findText(typeEl);
                    if (type != null) {
                        AntBasedProjectType provider = findAntBasedProjectType(type);
                        if (provider != null) {

            LOG.log(Level.FINE, "could not load {0}", projectDiskFile);
            return null;
        }
        Element typeEl = XMLUtil.findElement(projectXml.getDocumentElement(), "type", PROJECT_NS); // NOI18N
        if (typeEl == null) {
            LOG.log(Level.FINE, "no <type> in {0}", projectDiskFile);
            return null;
        }
        String type = XMLUtil.findText(typeEl);
        if (type == null) {
            LOG.log(Level.FINE, "no <type> text in {0}", projectDiskFile);
            return null;




    public static String getLibrariesLocationText(AuxiliaryConfiguration aux) {
        Element libraries = aux.getConfigurationFragment(EL_LIBRARIES, NAMESPACE, true);
        if (libraries != null) {
            for (Element definitions : XMLUtil.findSubElements(libraries)) {
                assert definitions.getLocalName().equals(EL_DEFINITIONS) : definitions;
                String text = XMLUtil.findText(definitions);
                assert text != null : aux;
                return text;
            }

        if (libraries == null) {
            libraries = XMLUtil.createDocument("dummy", null, null, null).createElementNS(NAMESPACE, EL_LIBRARIES); // NOI18N
        } else {
            List<Element> elements = XMLUtil.findSubElements(libraries);
            if (elements.size() == 1) {
                libraries.removeChild(elements.get(0));
            }




import org.openide.util.NbCollections;
import org.openide.xml.XMLUtil;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

                        try {
                            String ns2 = ns.substring(0, slash + 1) + Integer.toString(Integer.parseInt(ns.substring(slash + 1)) + 1);
                            if (_resolveURI(ns2) != null) {
                                Element data2 = XMLUtil.translateXML(data, ns2);
                                data.getParentNode().replaceChild(data2, data);
                                try {
                                    validate(attempt);

        return null;
    }

    private static Element translateXML(Element from, String namespace) { // XXX use #136595
        Element to = from.getOwnerDocument().createElementNS(namespace, from.getLocalName());
        NodeList nl = from.getChildNodes();
        int length = nl.getLength();
        for (int i = 0; i < length; i++) {
            Node node = nl.item(i);
            Node newNode;
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                newNode = translateXML((Element) node, namespace);
            } else {
                newNode = node.cloneNode(true);
            }
            to.appendChild(newNode);
        }
        NamedNodeMap m = from.getAttributes();
        for (int i = 0; i < m.getLength(); i++) {
            Node attr = m.item(i);
            to.setAttribute(attr.getNodeName(), attr.getNodeValue());
        }
        return to;
    }

}





package org.netbeans.modules.project.ant;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openide.util.Exceptions;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

    private Util() {}

    /**
     * Search for an XML element in the direct children of a parent.
     * DOM provides a similar method but it does a recursive search
     * which we do not want. It also gives a node list and we want
     * only one result.
     * @param parent a parent element
     * @param name the intended local name
     * @param namespace the intended namespace
     * @return the one child element with that name, or null if none or more than one
     */
    public static Element findElement(Element parent, String name, String namespace) {
        Element result = null;
        NodeList l = parent.getChildNodes();
        int len = l.getLength();
        for (int i = 0; i < len; i++) {
            if (l.item(i).getNodeType() == Node.ELEMENT_NODE) {
                Element el = (Element)l.item(i);
                if (namespace.equals(el.getNamespaceURI()) && name.equals(el.getLocalName())) {
                    if (result == null) {
                        result = el;
                    } else {
                        return null;
                    }
                }
            }
        }
        return result;
    }
    
    /**
     * Extract nested text from an element.
     * Currently does not handle coalescing text nodes, CDATA sections, etc.
     * @param parent a parent element
     * @return the nested text, or null if none was found
     */
    public static String findText(Element parent) {
        NodeList l = parent.getChildNodes();
        for (int i = 0; i < l.getLength(); i++) {
            if (l.item(i).getNodeType() == Node.TEXT_NODE) {
                Text text = (Text)l.item(i);
                return text.getNodeValue();
            }
        }
        return null;
    }
    
    /**
     * Find all direct child elements of an element.
     * More useful than {@link Element#getElementsByTagNameNS} because it does
     * not recurse into recursive child elements.
     * Children which are all-whitespace text nodes are ignored; others cause
     * an exception to be thrown.
     * @param parent a parent element in a DOM tree
     * @return a list of direct child elements (may be empty)
     * @throws IllegalArgumentException if there are non-element children besides whitespace
     */
    public static List<Element> findSubElements(Element parent) throws IllegalArgumentException {
        NodeList l = parent.getChildNodes();
        List<Element> elements = new ArrayList<Element>(l.getLength());
        for (int i = 0; i < l.getLength(); i++) {
            Node n = l.item(i);
            if (n.getNodeType() == Node.ELEMENT_NODE) {
                elements.add((Element)n);
            } else if (n.getNodeType() == Node.TEXT_NODE) {
                String text = ((Text)n).getNodeValue();
                if (text.trim().length() > 0) {
                    throw new IllegalArgumentException("non-ws text encountered in " + parent + ": " + text); // NOI18N
                }
            } else if (n.getNodeType() == Node.COMMENT_NODE) {
                // skip
            } else {
                throw new IllegalArgumentException("unexpected non-element child of " + parent + ": " + n); // NOI18N
            }
        }
        return elements;
    }
    
    /**
     * Create an XML error handler that rethrows errors and fatal errors and logs warnings.
     * @return a standard error handler
     */




        Document doc = getConfigurationXml(shared);
        if (shared) {
            Element project = doc.getDocumentElement();
            Element config = XMLUtil.findElement(project, "configuration", PROJECT_NS); // NOI18N
            assert config != null;
            return config;
        } else {

            public Element run() {
                synchronized (modifiedMetadataPaths) {
                    Element root = getConfigurationDataRoot(shared);
                    Element data = XMLUtil.findElement(root, elementName, namespace);
                    if (data != null) {
                        return cloneSafely(data);
                    } else {

            public Void run() {
                synchronized (modifiedMetadataPaths) {
                    Element root = getConfigurationDataRoot(shared);
                    Element existing = XMLUtil.findElement(root, fragment.getLocalName(), fragment.getNamespaceURI());
                    // XXX first compare to existing and return if the same
                    if (existing != null) {
                        root.removeChild(existing);

            public Boolean run() {
                synchronized (modifiedMetadataPaths) {
                    Element root = getConfigurationDataRoot(shared);
                    Element data = XMLUtil.findElement(root, elementName, namespace);
                    if (data != null) {
                        root.removeChild(data);
                        modifying(shared ? PROJECT_XML_PATH : PRIVATE_XML_PATH);




import org.netbeans.api.queries.CollocationQuery;
import org.netbeans.modules.project.ant.AntBasedProjectFactorySingleton;
import org.netbeans.modules.project.ant.ProjectLibraryProvider;
import org.netbeans.modules.project.ant.Util;
import org.netbeans.spi.project.AuxiliaryConfiguration;
import org.netbeans.spi.project.SubprojectProvider;
import org.openide.ErrorManager;

        // Linear search; always keeping references sorted first by foreign project
        // name, then by target name.
        Element nextRefEl = null;
        Iterator<Element> it = XMLUtil.findSubElements(references).iterator();
        while (it.hasNext()) {
            Element testRefEl = it.next();
            RawReference testRef = RawReference.create(testRefEl);

    
    private static boolean removeRawReferenceElement(String foreignProjectName, String id, Element references, boolean escaped) throws IllegalArgumentException {
        // As with addRawReference, do a linear search through.
        for (Element testRefEl : XMLUtil.findSubElements(references)) {
            RawReference testRef = RawReference.create(testRefEl);
            String refID = testRef.getID();
            String refName = testRef.getForeignProjectName();

    }
    
    private static RawReference[] getRawReferences(Element references) throws IllegalArgumentException {
        List<Element> subEls = XMLUtil.findSubElements(references);
        List<RawReference> refs = new ArrayList<RawReference>(subEls.size());
        for (Element subEl : subEls) {
            refs.add(RawReference.create(subEl));

    }
    
    private static RawReference getRawReference(String foreignProjectName, String id, Element references, boolean escaped) throws IllegalArgumentException {
        for (Element subEl : XMLUtil.findSubElements(references)) {
            RawReference ref = RawReference.create(subEl);
            String refID = ref.getID();
            String refName = ref.getForeignProjectName();

                if (idx == -1) {
                    throw new IllegalArgumentException("bad subelement name: " + elName); // NOI18N
                }
                String val = XMLUtil.findText(el);
                if (val == null) {
                    throw new IllegalArgumentException("empty subelement: " + el); // NOI18N
                }

            if (!REF_NAME.equals(xml.getLocalName()) || !REFS_NS2.equals(xml.getNamespaceURI())) {
                throw new IllegalArgumentException("bad element name: " + xml); // NOI18N
            }
            List nl = XMLUtil.findSubElements(xml);
            if (nl.size() < 6) {
                throw new IllegalArgumentException("missing or extra data: " + xml); // NOI18N
            }

                if (idx == -1) {
                    throw new IllegalArgumentException("bad subelement name: " + elName); // NOI18N
                }
                String val = XMLUtil.findText(el);
                if (val == null) {
                    throw new IllegalArgumentException("empty subelement: " + el); // NOI18N
                }

                if (!"properties".equals(el.getLocalName())) { // NOI18N
                    throw new IllegalArgumentException("bad subelement. expected 'properties': " + el); // NOI18N
                }
                for (Element el2 : XMLUtil.findSubElements(el)) {
                    String key = el2.getAttribute("name");
                    String value = XMLUtil.findText(el2);
                    // #53553: NPE
                    if (value == null) {
                        value = ""; // NOI18N

Lines 58-63 Link Here

(-)a/project.ant/test/unit/src/org/netbeans/modules/project/ant/AntBasedProjectFactorySingletonTest.java (-1 / +2 lines)
58	import org.openide.util.Lookup;	58	import org.openide.util.Lookup;
59	import org.openide.util.lookup.Lookups;	59	import org.openide.util.lookup.Lookups;
60	import org.openide.util.test.MockLookup;	60	import org.openide.util.test.MockLookup;
		61	import org.openide.xml.XMLUtil;
61	import org.w3c.dom.Element;	62	import org.w3c.dom.Element;
62		63
63	public class AntBasedProjectFactorySingletonTest extends NbTestCase {	64	public class AntBasedProjectFactorySingletonTest extends NbTestCase {
Lines 238-244 Link Here
238	}	239	}
239	private static String namesOfChildren(Element e) {	240	private static String namesOfChildren(Element e) {
240	StringBuilder b = new StringBuilder();	241	StringBuilder b = new StringBuilder();
241	for (Element kid : Util.findSubElements(e)) {	242	for (Element kid : XMLUtil.findSubElements(e)) {
242	if (b.length() > 0) {	243	if (b.length() > 0) {
243	b.append(' ');	244	b.append(' ');
244	}	245	}

Lines 225-233 Link Here

(-)a/project.ant/test/unit/src/org/netbeans/spi/project/support/ant/AntBasedTestUtil.java (-2 / +2 lines)
225		225
226	private String getText(String elementName) {	226	private String getText(String elementName) {
227	Element data = helper.getPrimaryConfigurationData(true);	227	Element data = helper.getPrimaryConfigurationData(true);
228	Element el = Util.findElement(data, elementName, "urn:test:shared");	228	Element el = XMLUtil.findElement(data, elementName, "urn:test:shared");
229	if (el != null) {	229	if (el != null) {
230	String text = Util.findText(el);	230	String text = XMLUtil.findText(el);
231	if (text != null) {	231	if (text != null) {
232	return text;	232	return text;
233	}	233	}




import org.netbeans.junit.NbTestCase;
import org.netbeans.junit.RandomlyFails;
import org.netbeans.modules.project.ant.ProjectLibraryProvider;
import org.netbeans.modules.project.ant.Util;
import org.netbeans.spi.project.AuxiliaryConfiguration;
import org.netbeans.spi.project.CacheDirectoryProvider;
import org.openide.filesystems.FileObject;

        Element data = h.getPrimaryConfigurationData(true);
        assertEquals("correct element name", "data", data.getLocalName());
        assertEquals("correct element namespace", "urn:test:shared", data.getNamespaceURI());
        Element stuff = XMLUtil.findElement(data, "shared-stuff", "urn:test:shared");
        assertNotNull("had nested stuff in it", stuff);
        data = h.getPrimaryConfigurationData(false);
        assertEquals("correct element name", "data", data.getLocalName());
        assertEquals("correct element namespace", "urn:test:private", data.getNamespaceURI());
        stuff = XMLUtil.findElement(data, "private-stuff", "urn:test:private");
        assertNotNull("had nested stuff in it", stuff);
    }
    

        }
        assertEquals("correct element name", "data", data.getLocalName());
        assertEquals("correct element namespace", "urn:test:shared", data.getNamespaceURI());
        Element stuff = XMLUtil.findElement(data, "shared-stuff", "urn:test:shared");
        /* This now retains the former contents:
        assertNull("had no stuff in it", stuff);
         */

        pm.saveProject(p);
        Document doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        Element root = doc.getDocumentElement();
        Element type = XMLUtil.findElement(root, "type", AntProjectHelper.PROJECT_NS);
        assertEquals("correct restored type", "test", XMLUtil.findText(type));
        Element config = XMLUtil.findElement(root, "configuration", AntProjectHelper.PROJECT_NS);
        assertNotNull("have <configuration>", config);
        data = XMLUtil.findElement(config, "data", "urn:test:shared");
        assertNotNull("have <data>", data);
        Element details = XMLUtil.findElement(data, "details", "urn:test:shared");
        assertNotNull("have <details>", details);
    }
    

    public void testPutPrimaryConfigurationData() throws Exception {
        h.addAntProjectListener(l);
        Element data = h.getPrimaryConfigurationData(true);
        assertNotNull("<shared-stuff/> is there to start", XMLUtil.findElement(data, "shared-stuff", "urn:test:shared"));
        assertTrue("project is not initially modified", !pm.isModified(p));
        assertEquals("gPCD fires no events", 0, l.events().length);
        assertNotNull("config data has an owner document", data.getOwnerDocument());

        data.appendChild(nue);
        assertTrue("project is not modified after uncommitted change", !pm.isModified(p));
        assertEquals("no events fired after uncommitted change", 0, l.events().length);
        assertEquals("after uncommitted change gPCD does not yet have new <misc/>", null, XMLUtil.findElement(h.getPrimaryConfigurationData(true), "misc", "urn:test:shared"));
        h.putPrimaryConfigurationData(data, true);
        assertTrue("project is modified after committed change", pm.isModified(p));
        AntProjectEvent[] evs = l.events();

        assertEquals("correct helper", h, evs[0].getHelper());
        assertEquals("correct path", AntProjectHelper.PROJECT_XML_PATH, evs[0].getPath());
        assertTrue("expected change", evs[0].isExpected());
        nue = XMLUtil.findElement(h.getPrimaryConfigurationData(true), "misc", "urn:test:shared");
        assertNotNull("after committed change gPCD has new <misc/>", nue);
        assertEquals("new element name is correct", "misc", nue.getLocalName());
        assertEquals("new element namespace is correct", "urn:test:shared", nue.getNamespaceURI());
        Document doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        Element configuration = XMLUtil.findElement(doc.getDocumentElement(), "configuration", AntProjectHelper.PROJECT_NS);
        assertNotNull("still has <configuration> on disk", configuration);
        data = XMLUtil.findElement(configuration, "data", "urn:test:shared");
        assertNotNull("still has <data> on disk", data);
        nue = XMLUtil.findElement(data, "misc", "urn:test:shared");
        assertEquals("<misc/> not yet on disk", null, nue);
        pm.saveProject(p);
        assertTrue("project is not modified after save", !pm.isModified(p));
        assertEquals("saving changes fires no new events", 0, l.events().length);
        nue = XMLUtil.findElement(h.getPrimaryConfigurationData(true), "misc", "urn:test:shared");
        assertNotNull("after save gPCD still has new <misc/>", nue);
        doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        configuration = XMLUtil.findElement(doc.getDocumentElement(), "configuration", AntProjectHelper.PROJECT_NS);
        assertNotNull("still has <configuration> on disk", configuration);
        data = XMLUtil.findElement(configuration, "data", "urn:test:shared");
        assertNotNull("still has <data> on disk", data);
        nue = XMLUtil.findElement(data, "misc", "urn:test:shared");
        assertNotNull("<misc/> now on disk", nue);
        // #42147: changes made on disk should result in firing of an AntProjectEvent
        ProjectManager.mutex().writeAccess(new Mutex.ExceptionAction<Void>() {

        assertFalse("unexpected change", evs[0].isExpected());
        assertEquals("correct new display name", "Some New Name", ProjectUtils.getInformation(p).getDisplayName());
        data = h.getPrimaryConfigurationData(true);
        Element stuff = XMLUtil.findElement(data, "other-shared-stuff", "urn:test:shared");
        assertNotNull("have <other-shared-stuff/> now", stuff);
        AuxiliaryConfiguration aux = p.getLookup().lookup(AuxiliaryConfiguration.class);
        data = aux.getConfigurationFragment("data", "urn:test:shared-aux", true);
        assertNotNull("have aux <data>", data);
        stuff = XMLUtil.findElement(data, "other-aux-shared-stuff", "urn:test:shared-aux");
        assertNotNull("have <other-aux-shared-stuff/> now", stuff);
        // XXX try private.xml too
        // XXX try modifying both XML files, or different parts of the same, and saving in a batch

        assertNotNull("found shared <data>", data);
        assertEquals("correct name", "data", data.getLocalName());
        assertEquals("correct namespace", "urn:test:shared-aux", data.getNamespaceURI());
        Element stuff = XMLUtil.findElement(data, "aux-shared-stuff", "urn:test:shared-aux");
        assertNotNull("found <aux-shared-stuff/>", stuff);
        assertEquals("gCF fires no changes", 0, l.events().length);
        // Check write of shared data.

        pm.saveProject(p);
        assertEquals("saving project fires no new changes", 0, l.events().length);
        Document doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        Element config = XMLUtil.findElement(doc.getDocumentElement(), "configuration", AntProjectHelper.PROJECT_NS);
        assertNotNull("<configuration> still exists", config);
        data = XMLUtil.findElement(config, "data", "urn:test:shared-aux");
        assertNotNull("<data> still exists", data);
        stuff = XMLUtil.findElement(data, "aux-shared-stuff", "urn:test:shared-aux");
        assertNotNull("still have <aux-shared-stuff/>", stuff);
        assertEquals("attr written correctly", "val", stuff.getAttribute("attr"));
        // Check read of private data.

        assertNotNull("found shared <data>", data);
        assertEquals("correct name", "data", data.getLocalName());
        assertEquals("correct namespace", "urn:test:private-aux", data.getNamespaceURI());
        stuff = XMLUtil.findElement(data, "aux-private-stuff", "urn:test:private-aux");
        assertNotNull("found <aux-private-stuff/>", stuff);
        assertEquals("gCF fires no changes", 0, l.events().length);
        // Check write of private data.

        assertEquals("saving project fires no new changes", 0, l.events().length);
        doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PRIVATE_XML_PATH);
        config = doc.getDocumentElement();
        data = XMLUtil.findElement(config, "data", "urn:test:private-aux");
        assertNotNull("<data> still exists", data);
        stuff = XMLUtil.findElement(data, "aux-private-stuff", "urn:test:private-aux");
        assertNotNull("still have <aux-private-stuff/>", stuff);
        assertEquals("attr written correctly", "val", stuff.getAttribute("attr"));
        // Check that missing fragments are not returned.

        data = aux.getConfigurationFragment("hello", "urn:test:whatever", true);
        assertNotNull("can retrieve new frag", data);
        doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        config = XMLUtil.findElement(doc.getDocumentElement(), "configuration", AntProjectHelper.PROJECT_NS);
        assertNotNull("<configuration> still exists", config);
        data = XMLUtil.findElement(config, "hello", "urn:test:whatever");
        assertNotNull("<hello> still exists", data);
        assertEquals("correct nested contents too", "stuff", XMLUtil.findText(data));
        // Try removing a fragment.
        assertFalse("project is unmodified", pm.isModified(p));
        assertTrue("can remove new frag", aux.removeConfigurationFragment("hello", "urn:test:whatever", true));

        assertNull("now frag is gone", aux.getConfigurationFragment("hello", "urn:test:whatever", true));
        pm.saveProject(p);
        doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        config = XMLUtil.findElement(doc.getDocumentElement(), "configuration", AntProjectHelper.PROJECT_NS);
        assertNotNull("<configuration> still exists", config);
        data = XMLUtil.findElement(config, "hello", "urn:test:whatever");
        assertNull("now <hello> is gone", data);
        assertFalse("cannot remove a frag that is not there", aux.removeConfigurationFragment("hello", "urn:test:whatever", true));
        assertFalse("trying to remove a nonexistent frag does not modify project", pm.isModified(p));

        aux.putConfigurationFragment(data, true);
        pm.saveProject(p);
        doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        config = XMLUtil.findElement(doc.getDocumentElement(), "configuration", AntProjectHelper.PROJECT_NS);
        String[] names = new String[]{"aaa-namespace", "aaaa-namespace", "bbb-name-sp", "bbb-namespace", "bbb-namespace-1", "ccc-namespace", "data-urn:test:shared", "data-urn:test:shared-aux"};
        int count = 0;
        NodeList list = config.getChildNodes();

        assertNotNull("AuxiliaryConfiguration present", aux);

        Element data = aux.getConfigurationFragment("data", "urn:test:private-aux", false);
        Element stuff = XMLUtil.findElement(data, "aux-private-stuff", "urn:test:private-aux");
        assertNotNull("found <aux-private-stuff/>", stuff);
        // Check write of private data.
        stuff.setAttribute("attr", "val");

        //check the data are written:
        Document doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PRIVATE_XML_PATH);
        Element config = doc.getDocumentElement();
        data = XMLUtil.findElement(config, "data", "urn:test:private-aux");
        assertNotNull("<data> still exists", data);
        stuff = XMLUtil.findElement(data, "aux-private-stuff", "urn:test:private-aux");
        assertNotNull("still have <aux-private-stuff/>", stuff);
        assertEquals("attr written correctly", "val", stuff.getAttribute("attr"));
        




import org.netbeans.api.project.TestUtil;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.project.ant.AntBuildExtenderAccessor;
import org.netbeans.modules.project.ant.Util;
import org.netbeans.spi.project.AuxiliaryConfiguration;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.modules.SpecificationVersion;
import org.openide.util.Utilities;
import org.openide.util.test.MockLookup;
import org.openide.xml.XMLUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

        assertNull("No build-impl.xml yet", bi);
        // Modify shared data in a project.
        Element primdata = h.getPrimaryConfigurationData(true);
        Element oldDisplayName = XMLUtil.findElement(primdata, "display-name", "urn:test:shared");
        assertNotNull("had a <display-name> before", oldDisplayName);
        Element displayName = primdata.getOwnerDocument().createElementNS("urn:test:shared", "display-name");
        displayName.appendChild(primdata.getOwnerDocument().createTextNode("New Name"));

        NodeList l = doc.getElementsByTagName("description");
        assertEquals("one <description> in build-impl.xml", 1, l.getLength());
        el = (Element)l.item(0);
        assertEquals("correct description", "New Name", XMLUtil.findText(el));
        // Clear build-impl.xml to test if it is rewritten.
        bi.delete();
        // Now make some irrelevant change - e.g. to private.xml - and check that there is no modification.




import org.netbeans.api.project.TestUtil;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.project.ant.AntBasedProjectFactorySingleton;
import org.netbeans.modules.project.ant.Util;
import org.netbeans.api.project.ProjectInformation;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Mutex;
import org.openide.util.MutexException;
import org.openide.util.test.MockLookup;
import org.openide.xml.XMLUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

                    NodeList l = doc.getElementsByTagNameNS(AntProjectHelper.PROJECT_NS, "type");
                    assertEquals("one <type>", 1, l.getLength());
                    Element el = (Element)l.item(0);
                    assertEquals("correct saved type", "test", XMLUtil.findText(el));
                    l = doc.getElementsByTagNameNS("urn:test:shared", "shared-stuff");
                    assertEquals("one <shared-stuff>", 1, l.getLength());
                    doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PRIVATE_XML_PATH);




import org.netbeans.api.queries.CollocationQuery;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.project.ant.ProjectLibraryProvider;
import org.netbeans.modules.project.ant.Util;
import org.netbeans.spi.project.AuxiliaryConfiguration;
import org.netbeans.spi.project.SubprojectProvider;
import org.netbeans.spi.queries.CollocationQueryImplementation;

import org.openide.filesystems.FileUtil;
import org.openide.util.lookup.Lookups;
import org.openide.util.test.MockLookup;
import org.openide.xml.XMLUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

        assertTrue("Project is still modified", pm.isModified(p));
        pm.saveProject(p);
        Document doc = AntBasedTestUtil.slurpXml(h, AntProjectHelper.PROJECT_XML_PATH);
        Element config = XMLUtil.findElement(doc.getDocumentElement(), "configuration", AntProjectHelper.PROJECT_NS);
        assertNotNull("have <configuration>", config);
        Element references = XMLUtil.findElement(config, ReferenceHelper.REFS_NAME, ReferenceHelper.REFS_NS);
        assertNotNull("have <references>", references);
        NodeList nl = references.getElementsByTagNameNS(ReferenceHelper.REFS_NS, "reference");
        assertEquals("have three <reference>s", 3, nl.getLength());

            Element reference = (Element)nl.item(i);
            for (int j = 0; j < 6; j++) {
                String elementName = elementNames[j];
                Element element = XMLUtil.findElement(reference, elementName, ReferenceHelper.REFS_NS);
                assertNotNull("had element " + elementName + " in ref #" + i, element);
                assertEquals("correct text in " + elementName + " in ref #" + i, values[i][j], XMLUtil.findText(element));
            }
        }
    }

        Element refs = p.getLookup().lookup(AuxiliaryConfiguration.class).getConfigurationFragment(ReferenceHelper.REFS_NAME, namespace, true);
        assertNotNull(refs);
        List<String> actualScriptLocations = new ArrayList<String>();
        for (Element ref : XMLUtil.findSubElements(refs)) {
            Element script = XMLUtil.findElement(ref, "script", namespace);
            actualScriptLocations.add(XMLUtil.findText(script));
        }
        assertEquals(Arrays.asList(scriptLocations), actualScriptLocations);
    }

Return to bug 136595

Lines 414-422 Link Here

(-)a/project.ant/src/org/netbeans/modules/project/ant/ProjectLibraryProvider.java (-3 / +3 lines)
414	public static String getLibrariesLocationText(AuxiliaryConfiguration aux) {	414	public static String getLibrariesLocationText(AuxiliaryConfiguration aux) {
415	Element libraries = aux.getConfigurationFragment(EL_LIBRARIES, NAMESPACE, true);	415	Element libraries = aux.getConfigurationFragment(EL_LIBRARIES, NAMESPACE, true);
416	if (libraries != null) {	416	if (libraries != null) {
417	for (Element definitions : Util.findSubElements(libraries)) {	417	for (Element definitions : XMLUtil.findSubElements(libraries)) {
418	assert definitions.getLocalName().equals(EL_DEFINITIONS) : definitions;	418	assert definitions.getLocalName().equals(EL_DEFINITIONS) : definitions;
419	String text = Util.findText(definitions);	419	String text = XMLUtil.findText(definitions);
420	assert text != null : aux;	420	assert text != null : aux;
421	return text;	421	return text;
422	}	422	}
Lines 990-996 Link Here
990	if (libraries == null) {	990	if (libraries == null) {
991	libraries = XMLUtil.createDocument("dummy", null, null, null).createElementNS(NAMESPACE, EL_LIBRARIES); // NOI18N	991	libraries = XMLUtil.createDocument("dummy", null, null, null).createElementNS(NAMESPACE, EL_LIBRARIES); // NOI18N
992	} else {	992	} else {
993	List<Element> elements = Util.findSubElements(libraries);	993	List<Element> elements = XMLUtil.findSubElements(libraries);
994	if (elements.size() == 1) {	994	if (elements.size() == 1) {
995	libraries.removeChild(elements.get(0));	995	libraries.removeChild(elements.get(0));
996	}	996	}

Lines 68-74 Link Here

(-)a/project.ant/src/org/netbeans/modules/project/ant/ProjectXMLCatalogReader.java (-24 / +1 lines)
68	import org.openide.util.NbCollections;	68	import org.openide.util.NbCollections;
69	import org.openide.xml.XMLUtil;	69	import org.openide.xml.XMLUtil;
70	import org.w3c.dom.Element;	70	import org.w3c.dom.Element;
71	import org.w3c.dom.NamedNodeMap;
72	import org.w3c.dom.Node;	71	import org.w3c.dom.Node;
73	import org.w3c.dom.NodeList;	72	import org.w3c.dom.NodeList;
74	import org.xml.sax.SAXException;	73	import org.xml.sax.SAXException;
Lines 251-257 Link Here
251	try {	250	try {
252	String ns2 = ns.substring(0, slash + 1) + Integer.toString(Integer.parseInt(ns.substring(slash + 1)) + 1);	251	String ns2 = ns.substring(0, slash + 1) + Integer.toString(Integer.parseInt(ns.substring(slash + 1)) + 1);
253	if (_resolveURI(ns2) != null) {	252	if (_resolveURI(ns2) != null) {
254	Element data2 = translateXML(data, ns2);	253	Element data2 = XMLUtil.translateXML(data, ns2);
255	data.getParentNode().replaceChild(data2, data);	254	data.getParentNode().replaceChild(data2, data);
256	try {	255	try {
257	validate(attempt);	256	validate(attempt);
Lines 315-340 Link Here
315	return null;	314	return null;
316	}	315	}
317		316
318	private static Element translateXML(Element from, String namespace) { // XXX use #136595
319	Element to = from.getOwnerDocument().createElementNS(namespace, from.getLocalName());
320	NodeList nl = from.getChildNodes();
321	int length = nl.getLength();
322	for (int i = 0; i < length; i++) {
323	Node node = nl.item(i);
324	Node newNode;
325	if (node.getNodeType() == Node.ELEMENT_NODE) {
326	newNode = translateXML((Element) node, namespace);
327	} else {
328	newNode = node.cloneNode(true);
329	}
330	to.appendChild(newNode);
331	}
332	NamedNodeMap m = from.getAttributes();
333	for (int i = 0; i < m.getLength(); i++) {
334	Node attr = m.item(i);
335	to.setAttribute(attr.getNodeName(), attr.getNodeValue());
336	}
337	return to;
338	}
339
340	}	317	}

Lines 416-422 Link Here

(-)a/project.ant/src/org/netbeans/spi/project/support/ant/AntProjectHelper.java (-4 / +4 lines)
416	Document doc = getConfigurationXml(shared);	416	Document doc = getConfigurationXml(shared);
417	if (shared) {	417	if (shared) {
418	Element project = doc.getDocumentElement();	418	Element project = doc.getDocumentElement();
419	Element config = Util.findElement(project, "configuration", PROJECT_NS); // NOI18N	419	Element config = XMLUtil.findElement(project, "configuration", PROJECT_NS); // NOI18N
420	assert config != null;	420	assert config != null;
421	return config;	421	return config;
422	} else {	422	} else {
Lines 888-894 Link Here
888	public Element run() {	888	public Element run() {
889	synchronized (modifiedMetadataPaths) {	889	synchronized (modifiedMetadataPaths) {
890	Element root = getConfigurationDataRoot(shared);	890	Element root = getConfigurationDataRoot(shared);
891	Element data = Util.findElement(root, elementName, namespace);	891	Element data = XMLUtil.findElement(root, elementName, namespace);
892	if (data != null) {	892	if (data != null) {
893	return cloneSafely(data);	893	return cloneSafely(data);
894	} else {	894	} else {
Lines 926-932 Link Here
926	public Void run() {	926	public Void run() {
927	synchronized (modifiedMetadataPaths) {	927	synchronized (modifiedMetadataPaths) {
928	Element root = getConfigurationDataRoot(shared);	928	Element root = getConfigurationDataRoot(shared);
929	Element existing = Util.findElement(root, fragment.getLocalName(), fragment.getNamespaceURI());	929	Element existing = XMLUtil.findElement(root, fragment.getLocalName(), fragment.getNamespaceURI());
930	// XXX first compare to existing and return if the same	930	// XXX first compare to existing and return if the same
931	if (existing != null) {	931	if (existing != null) {
932	root.removeChild(existing);	932	root.removeChild(existing);
Lines 968-974 Link Here
968	public Boolean run() {	968	public Boolean run() {
969	synchronized (modifiedMetadataPaths) {	969	synchronized (modifiedMetadataPaths) {
970	Element root = getConfigurationDataRoot(shared);	970	Element root = getConfigurationDataRoot(shared);
971	Element data = Util.findElement(root, elementName, namespace);	971	Element data = XMLUtil.findElement(root, elementName, namespace);
972	if (data != null) {	972	if (data != null) {
973	root.removeChild(data);	973	root.removeChild(data);
974	modifying(shared ? PROJECT_XML_PATH : PRIVATE_XML_PATH);	974	modifying(shared ? PROJECT_XML_PATH : PRIVATE_XML_PATH);

Lines 70-76 Link Here

(-)a/project.ant/src/org/netbeans/spi/project/support/ant/ReferenceHelper.java (-10 / +9 lines)
70	import org.netbeans.api.queries.CollocationQuery;	70	import org.netbeans.api.queries.CollocationQuery;
71	import org.netbeans.modules.project.ant.AntBasedProjectFactorySingleton;	71	import org.netbeans.modules.project.ant.AntBasedProjectFactorySingleton;
72	import org.netbeans.modules.project.ant.ProjectLibraryProvider;	72	import org.netbeans.modules.project.ant.ProjectLibraryProvider;
73	import org.netbeans.modules.project.ant.Util;
74	import org.netbeans.spi.project.AuxiliaryConfiguration;	73	import org.netbeans.spi.project.AuxiliaryConfiguration;
75	import org.netbeans.spi.project.SubprojectProvider;	74	import org.netbeans.spi.project.SubprojectProvider;
76	import org.openide.ErrorManager;	75	import org.openide.ErrorManager;
Lines 569-575 Link Here
569	// Linear search; always keeping references sorted first by foreign project	568	// Linear search; always keeping references sorted first by foreign project
570	// name, then by target name.	569	// name, then by target name.
571	Element nextRefEl = null;	570	Element nextRefEl = null;
572	Iterator<Element> it = Util.findSubElements(references).iterator();	571	Iterator<Element> it = XMLUtil.findSubElements(references).iterator();
573	while (it.hasNext()) {	572	while (it.hasNext()) {
574	Element testRefEl = it.next();	573	Element testRefEl = it.next();
575	RawReference testRef = RawReference.create(testRefEl);	574	RawReference testRef = RawReference.create(testRefEl);
Lines 816-822 Link Here
816		815
817	private static boolean removeRawReferenceElement(String foreignProjectName, String id, Element references, boolean escaped) throws IllegalArgumentException {	816	private static boolean removeRawReferenceElement(String foreignProjectName, String id, Element references, boolean escaped) throws IllegalArgumentException {
818	// As with addRawReference, do a linear search through.	817	// As with addRawReference, do a linear search through.
819	for (Element testRefEl : Util.findSubElements(references)) {	818	for (Element testRefEl : XMLUtil.findSubElements(references)) {
820	RawReference testRef = RawReference.create(testRefEl);	819	RawReference testRef = RawReference.create(testRefEl);
821	String refID = testRef.getID();	820	String refID = testRef.getID();
822	String refName = testRef.getForeignProjectName();	821	String refName = testRef.getForeignProjectName();
Lines 869-875 Link Here
869	}	868	}
870		869
871	private static RawReference[] getRawReferences(Element references) throws IllegalArgumentException {	870	private static RawReference[] getRawReferences(Element references) throws IllegalArgumentException {
872	List<Element> subEls = Util.findSubElements(references);	871	List<Element> subEls = XMLUtil.findSubElements(references);
873	List<RawReference> refs = new ArrayList<RawReference>(subEls.size());	872	List<RawReference> refs = new ArrayList<RawReference>(subEls.size());
874	for (Element subEl : subEls) {	873	for (Element subEl : subEls) {
875	refs.add(RawReference.create(subEl));	874	refs.add(RawReference.create(subEl));
Lines 911-917 Link Here
911	}	910	}
912		911
913	private static RawReference getRawReference(String foreignProjectName, String id, Element references, boolean escaped) throws IllegalArgumentException {	912	private static RawReference getRawReference(String foreignProjectName, String id, Element references, boolean escaped) throws IllegalArgumentException {
914	for (Element subEl : Util.findSubElements(references)) {	913	for (Element subEl : XMLUtil.findSubElements(references)) {
915	RawReference ref = RawReference.create(subEl);	914	RawReference ref = RawReference.create(subEl);
916	String refID = ref.getID();	915	String refID = ref.getID();
917	String refName = ref.getForeignProjectName();	916	String refName = ref.getForeignProjectName();
Lines 1693-1699 Link Here
1693	if (idx == -1) {	1692	if (idx == -1) {
1694	throw new IllegalArgumentException("bad subelement name: " + elName); // NOI18N	1693	throw new IllegalArgumentException("bad subelement name: " + elName); // NOI18N
1695	}	1694	}
1696	String val = Util.findText(el);	1695	String val = XMLUtil.findText(el);
1697	if (val == null) {	1696	if (val == null) {
1698	throw new IllegalArgumentException("empty subelement: " + el); // NOI18N	1697	throw new IllegalArgumentException("empty subelement: " + el); // NOI18N
1699	}	1698	}
Lines 1711-1717 Link Here
1711	if (!REF_NAME.equals(xml.getLocalName()) \|\| !REFS_NS2.equals(xml.getNamespaceURI())) {	1710	if (!REF_NAME.equals(xml.getLocalName()) \|\| !REFS_NS2.equals(xml.getNamespaceURI())) {
1712	throw new IllegalArgumentException("bad element name: " + xml); // NOI18N	1711	throw new IllegalArgumentException("bad element name: " + xml); // NOI18N
1713	}	1712	}
1714	List nl = Util.findSubElements(xml);	1713	List nl = XMLUtil.findSubElements(xml);
1715	if (nl.size() < 6) {	1714	if (nl.size() < 6) {
1716	throw new IllegalArgumentException("missing or extra data: " + xml); // NOI18N	1715	throw new IllegalArgumentException("missing or extra data: " + xml); // NOI18N
1717	}	1716	}
Lines 1726-1732 Link Here
1726	if (idx == -1) {	1725	if (idx == -1) {
1727	throw new IllegalArgumentException("bad subelement name: " + elName); // NOI18N	1726	throw new IllegalArgumentException("bad subelement name: " + elName); // NOI18N
1728	}	1727	}
1729	String val = Util.findText(el);	1728	String val = XMLUtil.findText(el);
1730	if (val == null) {	1729	if (val == null) {
1731	throw new IllegalArgumentException("empty subelement: " + el); // NOI18N	1730	throw new IllegalArgumentException("empty subelement: " + el); // NOI18N
1732	}	1731	}
Lines 1744-1752 Link Here
1744	if (!"properties".equals(el.getLocalName())) { // NOI18N	1743	if (!"properties".equals(el.getLocalName())) { // NOI18N
1745	throw new IllegalArgumentException("bad subelement. expected 'properties': " + el); // NOI18N	1744	throw new IllegalArgumentException("bad subelement. expected 'properties': " + el); // NOI18N
1746	}	1745	}
1747	for (Element el2 : Util.findSubElements(el)) {	1746	for (Element el2 : XMLUtil.findSubElements(el)) {
1748	String key = el2.getAttribute("name");	1747	String key = el2.getAttribute("name");
1749	String value = Util.findText(el2);	1748	String value = XMLUtil.findText(el2);
1750	// #53553: NPE	1749	// #53553: NPE
1751	if (value == null) {	1750	if (value == null) {
1752	value = ""; // NOI18N	1751	value = ""; // NOI18N

Lines 41-55 Link Here

(-)a/project.ant/src/org/netbeans/modules/project/ant/Util.java (-83 lines)
41		41
42	package org.netbeans.modules.project.ant;	42	package org.netbeans.modules.project.ant;
43		43
44	import java.util.ArrayList;
45	import java.util.List;
46	import java.util.logging.Level;	44	import java.util.logging.Level;
47	import java.util.logging.Logger;	45	import java.util.logging.Logger;
48	import org.openide.util.Exceptions;	46	import org.openide.util.Exceptions;
49	import org.w3c.dom.Element;
50	import org.w3c.dom.Node;
51	import org.w3c.dom.NodeList;
52	import org.w3c.dom.Text;
53	import org.xml.sax.ErrorHandler;	47	import org.xml.sax.ErrorHandler;
54	import org.xml.sax.SAXException;	48	import org.xml.sax.SAXException;
55	import org.xml.sax.SAXParseException;	49	import org.xml.sax.SAXParseException;
Lines 63-145 Link Here
63	private Util() {}	57	private Util() {}
64		58
65	/**	59	/**
66	* Search for an XML element in the direct children of a parent.
67	* DOM provides a similar method but it does a recursive search
68	* which we do not want. It also gives a node list and we want
69	* only one result.
70	* @param parent a parent element
71	* @param name the intended local name
72	* @param namespace the intended namespace
73	* @return the one child element with that name, or null if none or more than one
74	*/
75	public static Element findElement(Element parent, String name, String namespace) {
76	Element result = null;
77	NodeList l = parent.getChildNodes();
78	int len = l.getLength();
79	for (int i = 0; i < len; i++) {
80	if (l.item(i).getNodeType() == Node.ELEMENT_NODE) {
81	Element el = (Element)l.item(i);
82	if (namespace.equals(el.getNamespaceURI()) && name.equals(el.getLocalName())) {
83	if (result == null) {
84	result = el;
85	} else {
86	return null;
87	}
88	}
89	}
90	}
91	return result;
92	}
93
94	/**
95	* Extract nested text from an element.
96	* Currently does not handle coalescing text nodes, CDATA sections, etc.
97	* @param parent a parent element
98	* @return the nested text, or null if none was found
99	*/
100	public static String findText(Element parent) {
101	NodeList l = parent.getChildNodes();
102	for (int i = 0; i < l.getLength(); i++) {
103	if (l.item(i).getNodeType() == Node.TEXT_NODE) {
104	Text text = (Text)l.item(i);
105	return text.getNodeValue();
106	}
107	}
108	return null;
109	}
110
111	/**
112	* Find all direct child elements of an element.
113	* More useful than {@link Element#getElementsByTagNameNS} because it does
114	* not recurse into recursive child elements.
115	* Children which are all-whitespace text nodes are ignored; others cause
116	* an exception to be thrown.
117	* @param parent a parent element in a DOM tree
118	* @return a list of direct child elements (may be empty)
119	* @throws IllegalArgumentException if there are non-element children besides whitespace
120	*/
121	public static List<Element> findSubElements(Element parent) throws IllegalArgumentException {
122	NodeList l = parent.getChildNodes();
123	List<Element> elements = new ArrayList<Element>(l.getLength());
124	for (int i = 0; i < l.getLength(); i++) {
125	Node n = l.item(i);
126	if (n.getNodeType() == Node.ELEMENT_NODE) {
127	elements.add((Element)n);
128	} else if (n.getNodeType() == Node.TEXT_NODE) {
129	String text = ((Text)n).getNodeValue();
130	if (text.trim().length() > 0) {
131	throw new IllegalArgumentException("non-ws text encountered in " + parent + ": " + text); // NOI18N
132	}
133	} else if (n.getNodeType() == Node.COMMENT_NODE) {
134	// skip
135	} else {
136	throw new IllegalArgumentException("unexpected non-element child of " + parent + ": " + n); // NOI18N
137	}
138	}
139	return elements;
140	}
141
142	/**
143	* Create an XML error handler that rethrows errors and fatal errors and logs warnings.	60	* Create an XML error handler that rethrows errors and fatal errors and logs warnings.
144	* @return a standard error handler	61	* @return a standard error handler
145	*/	62	*/

Lines 52-64 Link Here

(-)a/project.ant/test/unit/src/org/netbeans/spi/project/support/ant/GeneratedFilesHelperTest.java (-3 / +3 lines)
52	import org.netbeans.api.project.TestUtil;	52	import org.netbeans.api.project.TestUtil;
53	import org.netbeans.junit.NbTestCase;	53	import org.netbeans.junit.NbTestCase;
54	import org.netbeans.modules.project.ant.AntBuildExtenderAccessor;	54	import org.netbeans.modules.project.ant.AntBuildExtenderAccessor;
55	import org.netbeans.modules.project.ant.Util;
56	import org.netbeans.spi.project.AuxiliaryConfiguration;	55	import org.netbeans.spi.project.AuxiliaryConfiguration;
57	import org.openide.filesystems.FileObject;	56	import org.openide.filesystems.FileObject;
58	import org.openide.filesystems.FileUtil;	57	import org.openide.filesystems.FileUtil;
59	import org.openide.modules.SpecificationVersion;	58	import org.openide.modules.SpecificationVersion;
60	import org.openide.util.Utilities;	59	import org.openide.util.Utilities;
61	import org.openide.util.test.MockLookup;	60	import org.openide.util.test.MockLookup;
		61	import org.openide.xml.XMLUtil;
62	import org.w3c.dom.Document;	62	import org.w3c.dom.Document;
63	import org.w3c.dom.Element;	63	import org.w3c.dom.Element;
64	import org.w3c.dom.NodeList;	64	import org.w3c.dom.NodeList;
Lines 111-117 Link Here
111	assertNull("No build-impl.xml yet", bi);	111	assertNull("No build-impl.xml yet", bi);
112	// Modify shared data in a project.	112	// Modify shared data in a project.
113	Element primdata = h.getPrimaryConfigurationData(true);	113	Element primdata = h.getPrimaryConfigurationData(true);
114	Element oldDisplayName = Util.findElement(primdata, "display-name", "urn:test:shared");	114	Element oldDisplayName = XMLUtil.findElement(primdata, "display-name", "urn:test:shared");
115	assertNotNull("had a <display-name> before", oldDisplayName);	115	assertNotNull("had a <display-name> before", oldDisplayName);
116	Element displayName = primdata.getOwnerDocument().createElementNS("urn:test:shared", "display-name");	116	Element displayName = primdata.getOwnerDocument().createElementNS("urn:test:shared", "display-name");
117	displayName.appendChild(primdata.getOwnerDocument().createTextNode("New Name"));	117	displayName.appendChild(primdata.getOwnerDocument().createTextNode("New Name"));
Lines 132-138 Link Here
132	NodeList l = doc.getElementsByTagName("description");	132	NodeList l = doc.getElementsByTagName("description");
133	assertEquals("one <description> in build-impl.xml", 1, l.getLength());	133	assertEquals("one <description> in build-impl.xml", 1, l.getLength());
134	el = (Element)l.item(0);	134	el = (Element)l.item(0);
135	assertEquals("correct description", "New Name", Util.findText(el));	135	assertEquals("correct description", "New Name", XMLUtil.findText(el));
136	// Clear build-impl.xml to test if it is rewritten.	136	// Clear build-impl.xml to test if it is rewritten.
137	bi.delete();	137	bi.delete();
138	// Now make some irrelevant change - e.g. to private.xml - and check that there is no modification.	138	// Now make some irrelevant change - e.g. to private.xml - and check that there is no modification.