TestFacesConfigOrdering.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.faces.config;

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.faces.context.FacesContext;

import com.sun.faces.cactus.ServletFacesTestCase;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Attr;

/**
 * Test cases to validate faces-config ordering.
 */
public class TestFacesConfigOrdering extends ServletFacesTestCase {


    // ------------------------------------------------------------ Constructors


    public TestFacesConfigOrdering()  {

        this("TestFacesConfigOrdering");

    }


    public TestFacesConfigOrdering(String name) {

        super(name);

    }


    // ------------------------------------------------------------ Test Methods


    public void testDocumentOrderingWrapperInit() throws Exception {

        // this should test segment should fail since this document is
        // before and after A
        List<String> docBeforeIds = new ArrayList<String>();
        Collections.addAll(docBeforeIds, "A");
        List<String> docAfterIds = new ArrayList<String>();
        Collections.addAll(docAfterIds, "A");

        try {
            new DocumentOrderingWrapper(createDocument("MyDoc", docBeforeIds, docAfterIds));
            fail("Expected DocumentOrderingWrapper to throw an exception when the wrapped document was configured to be before and after the same document.");
        } catch (ConfigurationException ce) {
            // expected
        }


        // this test segment ensures that 'empty defaults will be used if the
        // document has no document ID.
        DocumentOrderingWrapper w = new DocumentOrderingWrapper(createDocument(null, docBeforeIds, null));
        assertEquals("Expected DocumentOrderingWrapper.getDocumentId() to return an empty string when no ID was specified.  Received: " + w.getDocumentId(), "", w.getDocumentId());
        assertTrue(Arrays.equals(new String[] { "A" }, w.getBeforeIds()));
        assertTrue(Arrays.equals(new String[] {  }, w.getAfterIds()));

        docAfterIds.clear();
        Collections.addAll(docAfterIds, "others");
        w = new DocumentOrderingWrapper(createDocument("MyDoc", docBeforeIds, docAfterIds));
        assertEquals("Expected DocumentOrderingWrapper.getDocumentId() to return MyDoc, received: " + w.getDocumentId(), "MyDoc", w.getDocumentId());
        assertTrue(Arrays.equals(new String[] { "A" }, w.getBeforeIds()));
        assertTrue(Arrays.equals(new String[] { "others" }, w.getAfterIds()));
        
    }


    public void testAfterAfterOthersBeforeBeforeOthers() throws Exception {

        List<String> docAAfterIds = new ArrayList<String>();
        Collections.addAll(docAAfterIds, "@others", "C");
        List<String> docCAfterIds = new ArrayList<String>();
        Collections.addAll(docCAfterIds, "@others");
        List<String> docBBeforeIds = new ArrayList<String>();
        Collections.addAll(docBBeforeIds, "@others");
        List<String> docFBeforeIds = new ArrayList<String>();
        Collections.addAll(docFBeforeIds, "B", "@others");
        DocumentInfo docA = createDocument("A", null, docAAfterIds);
        DocumentInfo docB = createDocument("B", docBBeforeIds, null);
        DocumentInfo docC = createDocument("C", null, docCAfterIds);
        DocumentInfo docD = createDocument("D", null, null);
        DocumentInfo docE = createDocument("E", null, null);
        DocumentInfo docF = createDocument("F", docFBeforeIds, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD),
                           new DocumentOrderingWrapper(docE),
                           new DocumentOrderingWrapper(docF));

        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
        String[] ids = { "F", "B", "D", "E", "C", "A" };
        validate(ids, wrappers);

    }


    public void testBeforeAfterOthersSorting() throws Exception {

        List<String> docAAfterIds = new ArrayList<String>();
        Collections.addAll(docAAfterIds, "@others");

        List<String> docABeforeIds = new ArrayList<String>();
        Collections.addAll(docABeforeIds, "C");

        List<String> docBBeforeIds = new ArrayList<String>();
        Collections.addAll(docBBeforeIds, "@others");

        List<String> docDAfterIds = new ArrayList<String>();
        Collections.addAll(docDAfterIds, "@others");

        List<String> docEBeforeIds = new ArrayList<String>();
        Collections.addAll(docEBeforeIds, "@others");

        DocumentInfo docA = createDocument(null, docABeforeIds, docAAfterIds); // no ID here to ensure this works
        DocumentInfo docB = createDocument("B", docBBeforeIds, null);
        DocumentInfo docC = createDocument("C", null, null);
        DocumentInfo docD = createDocument("D", null, docDAfterIds);
        DocumentInfo docE = createDocument("E", docEBeforeIds, null);
        DocumentInfo docF = createDocument("F", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD),
                           new DocumentOrderingWrapper(docE),
                           new DocumentOrderingWrapper(docF));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
        String[] ids = { "B", "E", "F", "", "C", "D" };
        validate(ids, wrappers);

    }


    public void testAfterBeforeOthersSorting() throws Exception {

        List<String> docAAfterIds = new ArrayList<String>();
        Collections.addAll(docAAfterIds, "@others");

        List<String> docBBeforeIds = new ArrayList<String>();
        Collections.addAll(docBBeforeIds, "@others");

        List<String> docDAfterIds = new ArrayList<String>();
        Collections.addAll(docDAfterIds, "@others");

        List<String> docEBeforeIds = new ArrayList<String>();
        Collections.addAll(docEBeforeIds, "@others");
        List<String> docEAfterIds = new ArrayList<String>();
        Collections.addAll(docEAfterIds, "C");

        DocumentInfo docA = createDocument("A", null, docAAfterIds);
        DocumentInfo docB = createDocument("B", docBBeforeIds, null);
        DocumentInfo docC = createDocument("C", null, null);
        DocumentInfo docD = createDocument("D", null, docDAfterIds);
        DocumentInfo docE = createDocument("E", docEBeforeIds, docEAfterIds);
        DocumentInfo docF = createDocument("F", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD),
                           new DocumentOrderingWrapper(docE),
                           new DocumentOrderingWrapper(docF));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
        String[] ids = { "B", "C", "E", "F", "A", "D" };
        validate(ids, wrappers);

    }




    public void testSpecSimple() throws Exception {

        List<String> docAAfterIds = new ArrayList<String>();
        Collections.addAll(docAAfterIds, "B");
        List<String> docCBeforeIds = new ArrayList<String>();
        Collections.addAll(docCBeforeIds, "@others");
        DocumentInfo docA = createDocument("A", null, docAAfterIds);
        DocumentInfo docB = createDocument("B", null, null);
        DocumentInfo docC = createDocument("C", docCBeforeIds, null);
        DocumentInfo docD = createDocument("D", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
        String[] ids = { "C", "B", "D", "A" };
        validate(ids, wrappers);

    }


    public void testBeforeIdAfterOthers() throws Exception {

        List<String> docCBeforeIds = new ArrayList<String>();
        Collections.addAll(docCBeforeIds, "B");
        List<String> docCAfterIds = new ArrayList<String>();
        Collections.addAll(docCAfterIds, "@others");
        DocumentInfo docA = createDocument("A", null, null);
        DocumentInfo docB = createDocument("B", null, null);
        DocumentInfo docC = createDocument("C", docCBeforeIds, docCAfterIds);
        DocumentInfo docD = createDocument("D", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
                String[] ids = { "A", "D", "C", "B" };
        validate(ids, wrappers);

    }


    public void testAfterIdBeforeOthers() throws Exception {

        List<String> docCAfterIds = new ArrayList<String>();
        Collections.addAll(docCAfterIds, "D");
        List<String> docCBeforeIds = new ArrayList<String>();
        Collections.addAll(docCBeforeIds, "@others");
        DocumentInfo docA = createDocument("A", null, null);
        DocumentInfo docB = createDocument("B", null, null);
        DocumentInfo docC = createDocument("C", docCBeforeIds, docCAfterIds);
        DocumentInfo docD = createDocument("D", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
                String[] ids = { "D", "C", "A", "B" };
        validate(ids, wrappers);

    }

    
    public void testAllAfterSpecificIds() throws Exception {

        List<String> docAAfterIds = new ArrayList<String>();
        List<String> docBAfterIds = new ArrayList<String>();
        List<String> docCAfterIds = new ArrayList<String>();
        Collections.addAll(docAAfterIds, "B");
        Collections.addAll(docBAfterIds, "C");
        Collections.addAll(docCAfterIds, "D");
        DocumentInfo docA = createDocument("A", null, docAAfterIds);
        DocumentInfo docB = createDocument("B", null, docBAfterIds);
        DocumentInfo docC = createDocument("C", null, docCAfterIds);
        DocumentInfo docD = createDocument("D", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
                String[] ids = { "D", "C", "B", "A" };
        validate(ids, wrappers);

    }


    public void testAllBeforeSpecificIds() throws Exception {

        List<String> docBBeforeIds = new ArrayList<String>();
        List<String> docCBeforeIds = new ArrayList<String>();
        List<String> docDBeforeIds = new ArrayList<String>();
        Collections.addAll(docBBeforeIds, "A");
        Collections.addAll(docCBeforeIds, "B");
        Collections.addAll(docDBeforeIds, "C");
        DocumentInfo docA = createDocument("A", null, null);
        DocumentInfo docB = createDocument("B", docBBeforeIds, null);
        DocumentInfo docC = createDocument("C", docCBeforeIds, null);
        DocumentInfo docD = createDocument("D", docDBeforeIds, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        DocumentOrderingWrapper.sort(wrappers);
                String[] ids = { "D", "C", "B", "A" };
        validate(ids, wrappers);

    }


    public void testMixed1() throws Exception {

        List<String> docBAfterIds = new ArrayList<String>();
        List<String> docCBeforeIds = new ArrayList<String>();
        Collections.addAll(docBAfterIds, "C");
        Collections.addAll(docCBeforeIds, "B");
        DocumentInfo docA = createDocument("A", null, null);
        DocumentInfo docB = createDocument("B", null, docBAfterIds);
        DocumentInfo docC = createDocument("C", docCBeforeIds, null);
        DocumentInfo docD = createDocument("D", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        
        String[] originalOrder = (DocumentOrderingWrapper.getIds(wrappers)).toArray(new String[wrappers.length]);
        
        DocumentOrderingWrapper.sort(wrappers);
       
        String[] orderedNames = (DocumentOrderingWrapper.getIds(wrappers)).toArray(new String[wrappers.length]);
        
        List<String> original = Arrays.asList(originalOrder);
		List<String> actually = Arrays.asList(orderedNames);
        
		List<String> possibility1 = Arrays.asList("A", "C", "D", "B");
		List<String> possibility2 = Arrays.asList("C", "A", "D", "B");
		List<String> possibility3 = Arrays.asList("C", "D", "A", "B");
		
		boolean assertion = (
				actually.equals(possibility1) || 
				actually.equals(possibility2) || 
				actually.equals(possibility3)
			);
		String message = "\n original: " + original + "\n expected: " + possibility1 + 
				"\n       or: " + possibility2 +
				"\n       or: " + possibility3 +
				"\n actually: " + actually + "\n";
		assertTrue(message, assertion);

    }


    public void testCyclic1() throws Exception {

        List<String> docABeforeIds = new ArrayList<String>();
        List<String> docBBeforeIds = new ArrayList<String>();
        List<String> docCBeforeIds = new ArrayList<String>();
        Collections.addAll(docABeforeIds, "C");
        Collections.addAll(docBBeforeIds, "A");
        Collections.addAll(docCBeforeIds, "B");
        DocumentInfo docA = createDocument("A", docABeforeIds, null);
        DocumentInfo docB = createDocument("B", docBBeforeIds, null);
        DocumentInfo docC = createDocument("C", docCBeforeIds, null);
        DocumentInfo docD = createDocument("D", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);

        try {
            DocumentOrderingWrapper.sort(wrappers);
            fail("No exception thrown when circular document dependency is present");
        } catch (ConfigurationException ce) {
            // expected
        }

    }


    public void testCyclic2() throws Exception {

        List<String> docAAfterIds = new ArrayList<String>();
        List<String> docBAfterIds = new ArrayList<String>();
        List<String> docCAfterIds = new ArrayList<String>();
        Collections.addAll(docAAfterIds, "B");
        Collections.addAll(docBAfterIds, "C");
        Collections.addAll(docCAfterIds, "A");
        DocumentInfo docA = createDocument("A", null, docAAfterIds);
        DocumentInfo docB = createDocument("B", null, docBAfterIds);
        DocumentInfo docC = createDocument("C", null, docCAfterIds);
        DocumentInfo docD = createDocument("D", null, null);

        List<DocumentOrderingWrapper> documents =
              new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(documents,
                           new DocumentOrderingWrapper(docA),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docD));
        DocumentOrderingWrapper[] wrappers =
              documents.toArray(new DocumentOrderingWrapper[documents.size()]);
        
        try {
            DocumentOrderingWrapper.sort(wrappers);
            fail("No exception thrown when circular document dependency is present");
        } catch (ConfigurationException ce) {
            // expected
        }

    }


    public void testAbsoluteDocumentOrderingAPI() throws Exception {

        Document d = parseDocumentAsWebInfFacesConfig(getFacesContext(), "/WEB-INF/webinfAbsolute1.xml");
        FacesConfigInfo info = new FacesConfigInfo(new DocumentInfo(d, null));
        assertTrue(info.isWebInfFacesConfig());
        assertTrue(info.isVersionGreaterOrEqual(2.0));
        assertFalse(info.isMetadataComplete());
        List<String> ordering = info.getAbsoluteOrdering();
        assertNotNull(ordering);
        assertEquals(3, ordering.size());
        assertEquals("a", ordering.get(0));
        assertEquals("b", ordering.get(1));
        assertEquals("c", ordering.get(2));

        d = parseDocumentAsWebInfFacesConfig(getFacesContext(), "/WEB-INF/webinfAbsolute2.xml");
        info = new FacesConfigInfo(new DocumentInfo(d, null));
        assertTrue(info.isWebInfFacesConfig());
        assertTrue(info.isVersionGreaterOrEqual(2.0));
        assertTrue(info.isMetadataComplete());
        ordering = info.getAbsoluteOrdering();
        assertNotNull(ordering);
        assertEquals(4, ordering.size());
        assertEquals("a", ordering.get(0));
        assertEquals("b", ordering.get(1));
        assertEquals("others", ordering.get(2));
        assertEquals("c", ordering.get(3));

        d = parseDocumentAsWebInfFacesConfig(getFacesContext(), "/WEB-INF/webinfAbsolute3.xml");
        info = new FacesConfigInfo(new DocumentInfo(d, null));
        assertTrue(info.isWebInfFacesConfig());
        assertFalse(info.isVersionGreaterOrEqual(2.0));
        assertTrue(info.isMetadataComplete());
        ordering = info.getAbsoluteOrdering();
        assertNull(ordering);

        d = parseDocument(getFacesContext(), "/WEB-INF/webinfAbsolute1.xml");
        info = new FacesConfigInfo(new DocumentInfo(d, null));
        assertFalse(info.isWebInfFacesConfig());

    }


    public void testAbsoluteOrderingProcessing() throws Exception {

        DocumentInfo docA = createDocument("a", null, null);
        DocumentInfo docB = createDocument("b", null, null);
        DocumentInfo docC = createDocument("c", null, null);
        DocumentInfo docD = createDocument("d", null, null);
        DocumentInfo docE = createDocument("e", null, null);
        DocumentInfo docF = createDocument("f", null, null);
        List<DocumentOrderingWrapper> wrappers = new ArrayList<DocumentOrderingWrapper>();
        Collections.addAll(wrappers,
                           new DocumentOrderingWrapper(docF),
                           new DocumentOrderingWrapper(docE),
                           new DocumentOrderingWrapper(docD),
                           new DocumentOrderingWrapper(docC),
                           new DocumentOrderingWrapper(docB),
                           new DocumentOrderingWrapper(docA));
        DocumentOrderingWrapper[] documentWrappers =
              wrappers.toArray(new DocumentOrderingWrapper[wrappers.size()]);

        Document d = parseDocumentAsWebInfFacesConfig(getFacesContext(), "/WEB-INF/webinfAbsolute1.xml");
        FacesConfigInfo info = new FacesConfigInfo(new DocumentInfo(d, null));
        List<String> ordering = info.getAbsoluteOrdering();
        DocumentOrderingWrapper[] result =
              DocumentOrderingWrapper.sort(documentWrappers, ordering);
        assertEquals(3, result.length);
        assertEquals("a", result[0].getDocumentId());
        assertEquals("b", result[1].getDocumentId());
        assertEquals("c", result[2].getDocumentId());

        d = parseDocumentAsWebInfFacesConfig(getFacesContext(), "/WEB-INF/webinfAbsolute2.xml");
        info = new FacesConfigInfo(new DocumentInfo(d, null));
        ordering = info.getAbsoluteOrdering();
        result =
              DocumentOrderingWrapper.sort(documentWrappers, ordering);
        assertEquals(6, result.length);
        assertEquals("a", result[0].getDocumentId());
        assertEquals("b", result[1].getDocumentId());
        assertEquals("d", result[2].getDocumentId());
        assertEquals("e", result[3].getDocumentId());
        assertEquals("f", result[4].getDocumentId());
        assertEquals("c", result[5].getDocumentId());
    }


    // ---------------------------------------------------------- Helper Methods


    private void validate(String[] ids, DocumentOrderingWrapper[] wrappers) {

        for (int i = 0; i < wrappers.length; i++) {
            assertEquals("Expected ID " + ids[i] + " at index " + i + ", but received " + wrappers[i].getDocumentId(), ids[i], wrappers[i].getDocumentId());
        }

    }


    private Document parseDocument(FacesContext ctx, String path) throws Exception {

        DocumentBuilderFactory factory = DbfFactory.getFactory();
        factory.setValidating(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        return builder.parse(ctx.getExternalContext().getResourceAsStream(path));

    }


    private Document parseDocumentAsWebInfFacesConfig(FacesContext ctx, String path) throws Exception {

        Document d = parseDocument(ctx, path);
        Attr webInf = d.createAttribute(ConfigManager.WEB_INF_MARKER);
        webInf.setValue("true");
        d.getDocumentElement().getAttributes().setNamedItem(webInf);
        return d;

    }
    

    private DocumentInfo createDocument(String documentId,
                                    List<String> beforeIds,
                                    List<String> afterIds)
          throws Exception {

        String ns = "http://java.sun.com/xml/ns/javaee";
        Document document = newDocument();
        Element root = document.createElementNS(ns, "faces-config");
        if (documentId != null) {
            Element nameElement = document.createElementNS(ns, "name");
            nameElement.setTextContent(documentId);
            root.appendChild(nameElement);
        }
        document.appendChild(root);
        boolean hasBefore = (beforeIds != null && !beforeIds.isEmpty());
        boolean hasAfter = (afterIds != null && !afterIds.isEmpty());
        boolean createOrdering = (hasBefore || hasAfter);
        if (createOrdering) {
            Element ordering = document.createElementNS(ns, "ordering");
            root.appendChild(ordering);
            if (hasBefore) {
                populateIds("before", beforeIds, ns, document, ordering);
            }
            if (hasAfter) {
                populateIds("after", afterIds, ns, document, ordering);
            }
        }

        return new DocumentInfo(document, null);

    }


    private void populateIds(String elementName,
                             List<String> ids,
                             String ns,
                             Document document,
                             Element ordering) {

        Element element = document.createElementNS(ns, elementName);
        ordering.appendChild(element);
        for (String id : ids) {
            Element append;
            if ("@others".equals(id)) {
                append = document.createElementNS(ns, "others");
            } else {
                append = document.createElementNS(ns, "name");
                append.setTextContent(id);
            }
            element.appendChild(append);
        }

    }


    private Document newDocument() throws ParserConfigurationException {

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setValidating(false);
        factory.setNamespaceAware(true);
        return factory.newDocumentBuilder().newDocument();

    }

}