hazendaz / httpunit / 636

Committed 05 Dec 2025 03:27AM UTC coverage: 80.509%. Remained the same

Build # 636

Build Type

push

github

Committed by

hazendaz

Commit Message

Cleanup more old since tags

you guessed it, at this point going to jautodoc the rest so the warnings on builds go away ;)

Run Details

3213 of 4105 branches covered (78.27%)

Branch coverage included in aggregate %.

8249 of 10132 relevant lines covered (81.42%)

0.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.16

/src/main/java/com/meterware/httpunit/ParsedHTML.java

/*
 * MIT License
 *
 * Copyright 2011-2025 Russell Gold
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
 * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
 * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
package com.meterware.httpunit;

import com.meterware.httpunit.dom.HTMLContainerElement;
import com.meterware.httpunit.dom.HTMLControl;
import com.meterware.httpunit.dom.HTMLDocumentImpl;
import com.meterware.httpunit.scripting.ScriptableDelegate;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.html.HTMLAppletElement;
import org.w3c.dom.html.HTMLCollection;
import org.w3c.dom.html.HTMLFormElement;
import org.w3c.dom.html.HTMLImageElement;
import org.w3c.dom.html.HTMLTableCellElement;
import org.w3c.dom.html.HTMLTableRowElement;

public class ParsedHTML {

    static final private HTMLElement[] NO_ELEMENTS = {};

    static final private String[] TEXT_ELEMENTS = { "p", "h1", "h2", "h3", "h4", "h5", "h6" };

    private Node _rootNode;

    private URL _baseURL;

    private FrameSelector _frame;

    private String _baseTarget;

    private String _characterSet;

    private WebResponse _response;

    private boolean _updateElements = true;

    private boolean _enableNoScriptNodes;

    /** map of element IDs to elements. **/
    private HashMap _elementsByID = new HashMap<>();

    /** map of element names to lists of elements. **/
    private HashMap _elementsByName = new HashMap<>();

    /** map of element class to elements. **/
    private HashMap _elementsByClass = new HashMap<>();

    /** map of DOM elements to HTML elements **/
    private ElementRegistry _registry = new ElementRegistry();

    private ArrayList _blocksList = new ArrayList<>();
    private TextBlock[] _blocks;

    private ArrayList _tableList = new ArrayList<>();
    private WebTable[] _tables;

    private ArrayList _frameList = new ArrayList<>();
    private WebFrame[] _frames;

    ParsedHTML(WebResponse response, FrameSelector frame, URL baseURL, String baseTarget, Node rootNode,
            String characterSet) {
        _response = response;
        _frame = frame;
        _baseURL = baseURL;
        _baseTarget = baseTarget;
        _rootNode = rootNode;
        _characterSet = characterSet;
    }

    /**
     * Returns the forms found in the page in the order in which they appear.
     *
     * @return an array of objects representing the forms in the page or portion of a page.
     **/
    public WebForm[] getForms() {
        loadElements();
        HTMLCollection forms = ((HTMLContainerElement) _rootNode).getForms();
        WebForm[] result = new WebForm[forms.getLength()];
        for (int i = 0; i < result.length; i++) {
            result[i] = getWebForm(forms.item(i));
        }
        return result;
    }

    private WebForm getWebForm(Node node) {
        WebForm webForm = (WebForm) _registry.getRegisteredElement(node);
        return webForm != null ? webForm : (WebForm) _registry.registerElement(node, toWebForm((Element) node));
    }

    /**
     * Returns the links found in the page in the order in which they appear.
     **/
    public WebLink[] getLinks() {
        loadElements();
        HTMLCollection links = ((HTMLContainerElement) _rootNode).getLinks();
        WebLink[] result = new WebLink[links.getLength()];
        for (int i = 0; i < result.length; i++) {
            result[i] = (WebLink) _registry.getRegisteredElement(links.item(i));
            if (result[i] == null) {
                result[i] = new WebLink(_response, _baseURL, links.item(i), _frame, _baseTarget, _characterSet);
                _registry.registerElement(links.item(i), result[i]);
            }
        }
        return result;
    }

    /**
     * Returns a proxy for each applet found embedded in this page.
     */
    public WebApplet[] getApplets() {
        loadElements();
        HTMLCollection applets = ((HTMLContainerElement) _rootNode).getApplets();
        WebApplet[] result = new WebApplet[applets.getLength()];
        for (int i = 0; i < result.length; i++) {
            result[i] = (WebApplet) _registry.getRegisteredElement(applets.item(i));
            if (result[i] == null) {
                result[i] = new WebApplet(_response, (HTMLAppletElement) applets.item(i), _baseTarget);
                _registry.registerElement(applets.item(i), result[i]);
            }
        }
        return result;
    }

    /**
     * Returns the images found in the page in the order in which they appear.
     */
    public WebImage[] getImages() {
        loadElements();
        HTMLCollection images = ((HTMLContainerElement) _rootNode).getImages();
        WebImage[] result = new WebImage[images.getLength()];
        for (int i = 0; i < result.length; i++) {
            result[i] = (WebImage) _registry.getRegisteredElement(images.item(i));
            if (result[i] == null) {
                result[i] = new WebImage(_response, this, _baseURL, (HTMLImageElement) images.item(i), _frame,
                        _baseTarget, _characterSet);
                _registry.registerElement(images.item(i), result[i]);
            }
        }
        return result;
    }

    /**
     * Returns the top-level block elements found in the page in the order in which they appear.
     */
    public TextBlock[] getTextBlocks() {
        loadElements();
        if (_blocks == null) {
            loadElements();
            _blocks = (TextBlock[]) _blocksList.toArray(new TextBlock[_blocksList.size()]);
        }
        return _blocks;
    }

    /**
     * Returns the first text block found in the page which matches the specified predicate and value.
     */
    public TextBlock getFirstMatchingTextBlock(HTMLElementPredicate predicate, Object criteria) {
        loadElements();
        TextBlock[] blocks = getTextBlocks();
        for (TextBlock block : blocks) {
            if (predicate.matchesCriteria(block, criteria)) {
                return block;
            }
        }
        return null;
    }

    /**
     * get the next text block based on the given block
     *
     * @param block
     *
     * @return - the next text block
     */
    public TextBlock getNextTextBlock(TextBlock block) {
        loadElements();
        int index = _blocksList.indexOf(block);
        if (index < 0 || index == _blocksList.size() - 1) {
            return null;
        }
        return (TextBlock) _blocksList.get(index + 1);
    }

    /**
     * Returns the top-level tables found in the page in the order in which they appear.
     *
     * @return an array of tables
     **/
    public WebTable[] getTables() {
        loadElements();
        if (_tables == null) {
            _tables = (WebTable[]) _tableList.toArray(new WebTable[_tableList.size()]);
        }
        return _tables;
    }

    /**
     * Returns the HTMLElement with the specified ID.
     *
     * @param id
     *            - the id of the element to return
     *
     * @return the element looked for
     */
    public HTMLElement getElementWithID(String id) {
        return (HTMLElement) getElementWithID(id, HTMLElement.class);
    }

    /**
     * Returns the HTML elements with the specified name.
     */
    public HTMLElement[] getElementsWithName(String name) {
        loadElements();
        ArrayList elements = (ArrayList) _elementsByName.get(name);
        return elements == null ? NO_ELEMENTS : (HTMLElement[]) elements.toArray(new HTMLElement[elements.size()]);
    }

    /**
     * Returns the HTML elements with the specified class.
     */
    public HTMLElement[] getElementsWithClassName(String className) {
        loadElements();
        ArrayList elements = (ArrayList) _elementsByClass.get(className);
        return elements == null ? NO_ELEMENTS : (HTMLElement[]) elements.toArray(new HTMLElement[elements.size()]);
    }

    /**
     * Returns the HTML elements with an attribute with the specified name and value.
     *
     * @param name
     *            - the name of the attribute to check
     * @param value
     *            - the value of the attribute to check
     */
    public HTMLElement[] getElementsWithAttribute(String name, String value) {
        loadElements();
        ArrayList elements = new ArrayList<>();
        for (Iterator i = _registry.iterator(); i.hasNext();) {
            HTMLElement element = (HTMLElement) i.next();
            String aValue = element.getAttribute(name);
            if (value.equals(aValue)) {
                // System.err.println(element.getTagName()+"("+name+")="+aValue);
                elements.add(element);
            }
        }
        return (HTMLElement[]) elements.toArray(new HTMLElement[elements.size()]);
    }

    /**
     * Returns a list of HTML element names contained in this HTML section.
     */
    public String[] getElementNames() {
        loadElements();
        return (String[]) _elementsByName.keySet().toArray(new String[_elementsByName.size()]);
    }

    /**
     * get the elements with the given tagname
     *
     * @param dom
     *            - the node to start from
     * @param name
     *            - the name of the attribute to look for
     *
     * @return
     */
    HTMLElement[] getElementsByTagName(Node dom, String name) {
        loadElements();
        if (dom instanceof Element) {
            return getElementsFromList(((Element) dom).getElementsByTagName(name));
        }
        return getElementsFromList(((Document) dom).getElementsByTagName(name));
    }

    private HTMLElement[] getElementsFromList(NodeList nl) {
        HTMLElement[] elements = new HTMLElement[nl.getLength()];
        for (int i = 0; i < elements.length; i++) {
            Node node = nl.item(i);
            elements[i] = (HTMLElement) _registry.getRegisteredElement(node);
            if (elements[i] == null) {
                elements[i] = toDefaultElement((Element) node);
                _registry.registerElement(node, elements[i]);
            }
        }
        return elements;
    }

    /**
     * Returns the form found in the page with the specified ID.
     **/
    public WebForm getFormWithID(String id) {
        return (WebForm) getElementWithID(id, WebForm.class);
    }

    /**
     * Returns the link found in the page with the specified ID.
     **/
    public WebLink getLinkWithID(String id) {
        return (WebLink) getElementWithID(id, WebLink.class);

    }

    private Object getElementWithID(String id, final Class klass) {
        loadElements();
        return whenCast(_elementsByID.get(id), klass);
    }

    private Object whenCast(Object o, Class klass) {
        return klass.isInstance(o) ? o : null;
    }

    /**
     * Returns the first link found in the page matching the specified criteria.
     **/
    public WebForm getFirstMatchingForm(HTMLElementPredicate predicate, Object criteria) {
        WebForm[] forms = getForms();
        for (WebForm form : forms) {
            if (predicate.matchesCriteria(form, criteria)) {
                return form;
            }
        }
        return null;
    }

    /**
     * Returns all links found in the page matching the specified criteria.
     **/
    public WebForm[] getMatchingForms(HTMLElementPredicate predicate, Object criteria) {
        ArrayList matches = new ArrayList<>();
        WebForm[] forms = getForms();
        for (WebForm form : forms) {
            if (predicate.matchesCriteria(form, criteria)) {
                matches.add(form);
            }
        }
        return (WebForm[]) matches.toArray(new WebForm[matches.size()]);
    }

    /**
     * Returns the form found in the page with the specified name.
     **/
    public WebForm getFormWithName(String name) {
        return getFirstMatchingForm(WebForm.MATCH_NAME, name);
    }

    /**
     * interpret the given script element
     *
     * @param element
     */
    void interpretScriptElement(Element element) {
        if (!HttpUnitOptions.isScriptingEnabled()) {
            _enableNoScriptNodes = true;
            return;
        }

        String script = getScript(element);
        if (script != null) {
            try {
                _updateElements = false;
                String language = NodeUtils.getNodeAttribute(element, "language", null);
                if (!getResponse().getScriptingHandler().supportsScriptLanguage(language)) {
                    _enableNoScriptNodes = true;
                }
                getResponse().getScriptingHandler().runScript(language, script);
            } finally {
                clearCaches();
            }
        }
    }

    /**
     * get the script for the given node
     *
     * @param scriptNode
     *
     * @return the script
     */
    private String getScript(Node scriptNode) {
        String scriptLocation = NodeUtils.getNodeAttribute(scriptNode, "src", null);
        if (scriptLocation == null) {
            return NodeUtils.asText(scriptNode.getChildNodes());
        }
        try {
            return getIncludedScript(scriptLocation);
        } catch (Exception e) {
            throw new RuntimeException("Error loading included script: " + e);
        }
    }

    /**
     * Returns the contents of an included script, given its src attribute.
     *
     * @param srcAttribute
     *            the location of the script.
     *
     * @return the contents of the script.
     *
     * @throws IOException
     *             if there is a problem retrieving the script
     */
    String getIncludedScript(String srcAttribute) throws IOException {
        WebRequest req = new GetMethodWebRequest(getBaseURL(), srcAttribute);
        WebWindow window = getResponse().getWindow();
        if (window == null) {
            throw new IllegalStateException(
                    "Unable to retrieve script included by this response, since it was loaded by getResource(). Use getResponse() instead.");
        }
        WebResponse response = window.getResource(req);
        // check whether the Source is available
        int code = response.getResponseCode();
        // if everything is o.k.
        if (code <= HttpURLConnection.HTTP_BAD_REQUEST) {
            return response.getText();
        }
        // in this case the text would be an error message
        // we do not return it but set the
        ScriptException se = new ScriptException(
                "reponseCode " + code + " on getIncludedScript for src='" + srcAttribute + "'");
        String badScript = null;
        // let scripting engine decide what to do with this exception (throw it or remember it ...)
        HttpUnitOptions.getScriptingEngine().handleScriptException(se, badScript);
        return "";
    }

    /**
     * If noscript node content is enabled, returns null - otherwise returns a concealing element.
     */
    private HTMLElement toNoscriptElement(Element element) {
        HTMLElement result = null;
        if (!_enableNoScriptNodes) {
            result = new NoScriptElement(element);
        }
        return result;
    }

    static class HtmlElementRecorder {

        protected void recordHtmlElement(NodeUtils.PreOrderTraversal pot, Node node, HTMLElement htmlElement) {
            if (htmlElement != null) {
                addToMaps(pot, node, htmlElement);
                addToLists(pot, htmlElement);
            }
        }

        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
            for (Iterator i = pot.getContexts(); i.hasNext();) {
                Object o = i.next();
                if (o instanceof ParsedHTML) {
                    ((ParsedHTML) o).addToList(htmlElement);
                }
            }
        }

        protected void addToMaps(NodeUtils.PreOrderTraversal pot, Node node, HTMLElement htmlElement) {
            for (Iterator i = pot.getContexts(); i.hasNext();) {
                Object o = i.next();
                if (o instanceof ParsedHTML) {
                    ((ParsedHTML) o).addToMaps(node, htmlElement);
                }
            }
        }

    }

    abstract static class HTMLElementFactory extends HtmlElementRecorder {
        abstract HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element);

        void recordElement(NodeUtils.PreOrderTraversal pot, Element element, ParsedHTML parsedHTML) {
            HTMLElement htmlElement = toHTMLElement(pot, parsedHTML, element);
            recordHtmlElement(pot, element, htmlElement);
        }

        protected boolean isRecognized(ClientProperties properties) {
            return true;
        }

        protected boolean addToContext() {
            return false;
        }

        protected final ParsedHTML getParsedHTML(NodeUtils.PreOrderTraversal pot) {
            return (ParsedHTML) getClosestContext(pot, ParsedHTML.class);
        }

        protected final Object getClosestContext(NodeUtils.PreOrderTraversal pot, Class aClass) {
            return pot.getClosestContext(aClass);
        }

        protected ParsedHTML getRootContext(NodeUtils.PreOrderTraversal pot) {
            return (ParsedHTML) pot.getRootContext();
        }
    }

    static class DefaultElementFactory extends HTMLElementFactory {

        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            // [ 1531005 ] getElementsWithAttribute **FIX**
            // if (element.getAttribute( "id" ).equals( "" )) {
            // return null;
            // }
            return parsedHTML.toDefaultElement(element);
        }

        @Override
        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
        }
    }

    private HTMLElement toDefaultElement(Element element) {
        return new HTMLElementBase(element) {
            @Override
            public ScriptableDelegate newScriptable() {
                return new HTMLElementScriptable(this);
            }

            @Override
            public ScriptableDelegate getParentDelegate() {
                return getResponse().getDocumentScriptable();
            }
        };
    }

    static class WebFormFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toWebForm(element);
        }
    }

    static class WebLinkFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toLinkAnchor(element);
        }
    }

    static class TextBlockFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toTextBlock(element);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }

        @Override
        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
            for (Iterator i = pot.getContexts(); i.hasNext();) {
                Object o = i.next();
                if (!(o instanceof ParsedHTML)) {
                    continue;
                }
                ((ParsedHTML) o).addToList(htmlElement);
                break;
            }
        }

    }

    static class ScriptFactory extends HTMLElementFactory {

        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return null;
        }

        @Override
        void recordElement(NodeUtils.PreOrderTraversal pot, Element element, ParsedHTML parsedHTML) {
            parsedHTML.interpretScriptElement(element);
        }
    }

    static class NoScriptFactory extends HTMLElementFactory {

        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toNoscriptElement(element);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }
    }

    static class WebFrameFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toWebFrame(element);
        }
    }

    static class WebIFrameFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toWebIFrame(element);
        }

        @Override
        protected boolean isRecognized(ClientProperties properties) {
            return properties.isIframeSupported();
        }

        @Override
        protected boolean addToContext() {
            return true;
        }
    }

    static class WebImageFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toWebImage(element);
        }
    }

    static class WebAppletFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toWebApplet(element);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }
    }

    static class WebTableFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toWebTable(element);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }

        @Override
        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
            for (Iterator i = pot.getContexts(); i.hasNext();) {
                Object o = i.next();
                if (o instanceof ParsedHTML) {
                    ((ParsedHTML) o).addToList(htmlElement);
                }
                if (o instanceof TableCell) {
                    break;
                }
            }
        }
    }

    static class TableRowFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            WebTable wt = getWebTable(pot);
            if (wt == null) {
                return null;
            }
            return wt.newTableRow((HTMLTableRowElement) element);
        }

        private WebTable getWebTable(NodeUtils.PreOrderTraversal pot) {
            return (WebTable) getClosestContext(pot, WebTable.class);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }

        @Override
        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
            getWebTable(pot).addRow((TableRow) htmlElement);
        }
    }

    static class TableCellFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            TableRow tr = getTableRow(pot);
            if (tr == null) {
                return null;
            }
            return tr.newTableCell((HTMLTableCellElement) element);
        }

        private TableRow getTableRow(NodeUtils.PreOrderTraversal pot) {
            return (TableRow) getClosestContext(pot, TableRow.class);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }

        @Override
        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
            getTableRow(pot).addTableCell((TableCell) htmlElement);
        }
    }

    static class FormControlFactory extends HTMLElementFactory {

        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            HTMLFormElement form = ((HTMLControl) element).getForm();
            if (form == null) {
                return newControlWithoutForm(parsedHTML, element);
            }
            return parsedHTML.getWebForm(form).newFormControl(element);
        }

        private HTMLElement newControlWithoutForm(ParsedHTML parsedHTML, Element element) {
            if ((element.getNodeName().equalsIgnoreCase("button") || element.getNodeName().equalsIgnoreCase("input"))
                    && isValidNonFormButtonType(NodeUtils.getNodeAttribute(element, "type"))) {
                return parsedHTML.toButtonWithoutForm(element);
            }
            return null;
        }

        private boolean isValidNonFormButtonType(String buttonType) {
            return buttonType.equals("") || buttonType.equalsIgnoreCase("button");
        }
    }

    static class WebListFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            return parsedHTML.toOrderedList(element);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }

        @Override
        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
            TextBlock textBlock = getTextBlock(pot);
            if (textBlock != null) {
                textBlock.addList((WebList) htmlElement);
            }
        }

        private TextBlock getTextBlock(NodeUtils.PreOrderTraversal pot) {
            return (TextBlock) getClosestContext(pot, TextBlock.class);
        }
    }

    static class ListItemFactory extends HTMLElementFactory {
        @Override
        HTMLElement toHTMLElement(NodeUtils.PreOrderTraversal pot, ParsedHTML parsedHTML, Element element) {
            WebList webList = getWebList(pot);
            if (webList == null) {
                return null;
            }
            return webList.addNewItem(element);
        }

        private WebList getWebList(NodeUtils.PreOrderTraversal pot) {
            return (WebList) getClosestContext(pot, WebList.class);
        }

        @Override
        protected boolean addToContext() {
            return true;
        }

        @Override
        protected void addToLists(NodeUtils.PreOrderTraversal pot, HTMLElement htmlElement) {
        }
    }

    private static HashMap _htmlFactoryClasses = new HashMap<>();
    private static HTMLElementFactory _defaultFactory = new DefaultElementFactory();

    static {
        _htmlFactoryClasses.put("a", new WebLinkFactory());
        _htmlFactoryClasses.put("area", new WebLinkFactory());
        _htmlFactoryClasses.put("form", new WebFormFactory());
        _htmlFactoryClasses.put("img", new WebImageFactory());
        _htmlFactoryClasses.put("applet", new WebAppletFactory());
        _htmlFactoryClasses.put("table", new WebTableFactory());
        _htmlFactoryClasses.put("tr", new TableRowFactory());
        _htmlFactoryClasses.put("td", new TableCellFactory());
        _htmlFactoryClasses.put("th", new TableCellFactory());
        _htmlFactoryClasses.put("frame", new WebFrameFactory());
        _htmlFactoryClasses.put("iframe", new WebIFrameFactory());
        _htmlFactoryClasses.put("script", new ScriptFactory());
        _htmlFactoryClasses.put("noscript", new NoScriptFactory());
        _htmlFactoryClasses.put("ol", new WebListFactory());
        _htmlFactoryClasses.put("ul", new WebListFactory());
        _htmlFactoryClasses.put("li", new ListItemFactory());

        for (String element : TEXT_ELEMENTS) {
            _htmlFactoryClasses.put(element, new TextBlockFactory());
        }

        for (Iterator i = Arrays.asList(FormControl.getControlElementTags()).iterator(); i.hasNext();) {
            _htmlFactoryClasses.put(i.next(), new FormControlFactory());
        }
    }

    private static HTMLElementFactory getHTMLElementFactory(String tagName) {
        final HTMLElementFactory factory = (HTMLElementFactory) _htmlFactoryClasses.get(tagName);
        return factory != null ? factory : _defaultFactory;
    }

    private void loadElements() {
        if (!_updateElements) {
            return;
        }

        NodeUtils.NodeAction action = new NodeUtils.NodeAction() {
            @Override
            public boolean processElement(NodeUtils.PreOrderTraversal pot, Element element) {
                HTMLElementFactory factory = getHTMLElementFactory(element.getNodeName().toLowerCase());
                if (factory == null || !factory.isRecognized(getClientProperties())
                        || pot.getClosestContext(ContentConcealer.class) != null) {
                    return true;
                }

                if (!_registry.hasNode(element)) {
                    factory.recordElement(pot, element, ParsedHTML.this);
                }
                if (factory.addToContext()) {
                    pot.pushContext(_registry.getRegisteredElement(element));
                }

                return true;
            }

            @Override
            public void processTextNode(NodeUtils.PreOrderTraversal pot, Node textNode) {
                if (textNode.getNodeValue().trim().isEmpty()) {
                    return;
                }

                Node parent = textNode.getParentNode();
                if (!parent.getNodeName().equalsIgnoreCase("body")
                        || pot.getClosestContext(ContentConcealer.class) != null) {
                    return;
                }
                new HtmlElementRecorder().recordHtmlElement(pot, textNode, newTextBlock(textNode));
            }
        };
        NodeUtils.PreOrderTraversal nt = new NodeUtils.PreOrderTraversal(getRootNode());
        nt.pushBaseContext(this);
        nt.perform(action);

        _updateElements = false;
    }

    private ClientProperties getClientProperties() {
        WebWindow window = _response.getWindow();
        return window == null ? ClientProperties.getDefaultProperties() : window.getClient().getClientProperties();
    }

    private Button toButtonWithoutForm(Element element) {
        return new Button(_response, (HTMLControl) element);
    }

    private WebForm toWebForm(Element element) {
        return new WebForm(_response, _baseURL, element, _frame, _baseTarget, _characterSet, _registry);
    }

    private WebFrame toWebFrame(Element element) {
        return new WebFrame(_response, _baseURL, element, _frame);
    }

    private WebFrame toWebIFrame(Element element) {
        return new WebIFrame(_baseURL, element, _frame);
    }

    /**
     * convert the given child to a link anchor
     *
     * @param child
     *
     * @return
     */
    private WebLink toLinkAnchor(Element child) {
        return !isWebLink(child) ? null : new WebLink(_response, _baseURL, child, _frame, _baseTarget, _characterSet);
    }

    /**
     * check whether the given node is a Web link by checking that the node is of type "A"
     *
     * @param node
     *            - the node to check
     *
     * @return whether the given node represents a web link
     */
    public static boolean isWebLink(Node node) {
        /*
         * Bug report [ 1156972 ] isWebLink doesn't recognize all anchor tags by fregienj claims this be changed to
         * check whether the case-insensitive node name is "A" -> should be isAnchor method and getAnchor
         */
        boolean result = false;
        String tagName = ((Element) node).getTagName();
        if (!tagName.equalsIgnoreCase("area") && !tagName.equalsIgnoreCase("a")) {
        } else {
            // pre 1.7 code - still active
            result = node.getAttributes().getNamedItem("href") != null;
            // proposed patch - not activated
            // result=true;
        }
        return result;
    }

    private WebImage toWebImage(Element child) {
        return new WebImage(_response, this, _baseURL, (HTMLImageElement) child, _frame, _baseTarget, _characterSet);
    }

    private WebApplet toWebApplet(Element element) {
        return new WebApplet(_response, (HTMLAppletElement) element, _baseTarget);
    }

    private WebTable toWebTable(Element element) {
        return new WebTable(_response, _frame, element, _baseURL, _baseTarget, _characterSet);
    }

    private TextBlock toTextBlock(Element element) {
        return new TextBlock(_response, _frame, _baseURL, _baseTarget, element, _characterSet);
    }

    private TextBlock newTextBlock(Node textNode) {
        return new TextBlock(_response, _frame, _baseURL, _baseTarget, textNode, _characterSet);
    }

    private WebList toOrderedList(Element element) {
        return new WebList(_response, _frame, _baseURL, _baseTarget, element, _characterSet);
    }

    private void addToMaps(Node node, HTMLElement htmlElement) {
        _registry.registerElement(node, htmlElement);
        if (htmlElement.getID() != null) {
            _elementsByID.put(htmlElement.getID(), htmlElement);
        }
        if (htmlElement.getName() != null) {
            addNamedElement(htmlElement.getName(), htmlElement);
        }
        if (htmlElement.getClassName() != null) {
            StringTokenizer tokenizer = new StringTokenizer(htmlElement.getClassName());
            String token;

            while (tokenizer.hasMoreElements()) {
                token = tokenizer.nextToken();

                if (_elementsByClass.containsKey(token)) {
                    ((ArrayList) _elementsByClass.get(token)).add(htmlElement);
                } else {
                    ArrayList arrayList = new ArrayList<>();
                    arrayList.add(htmlElement);
                    _elementsByClass.put(token, arrayList);
                }
            }
        }
    }

    private void addNamedElement(String name, HTMLElement htmlElement) {
        List list = (List) _elementsByName.get(name);
        if (list == null) {
            _elementsByName.put(name, list = new ArrayList<>());
        }
        list.add(htmlElement);
    }

    private void addToList(HTMLElement htmlElement) {
        ArrayList list = getListForElement(htmlElement);
        if (list != null) {
            list.add(htmlElement);
        }
    }

    private ArrayList getListForElement(HTMLElement element) {
        if (element instanceof WebTable) {
            return _tableList;
        }
        if (element instanceof WebFrame) {
            return _frameList;
        }
        if (element instanceof BlockElement) {
            return _blocksList;
        }
        return null;
    }

    /**
     * Returns the first link which contains the specified text.
     **/
    public WebLink getLinkWith(String text) {
        return getFirstMatchingLink(WebLink.MATCH_CONTAINED_TEXT, text);
    }

    /**
     * Returns the link which contains the first image with the specified text as its 'alt' attribute.
     **/
    public WebLink getLinkWithImageText(String text) {
        WebImage image = getImageWithAltText(text);
        return image == null ? null : image.getLink();
    }

    /**
     * Returns the link found in the page with the specified name.
     **/
    public WebLink getLinkWithName(String name) {
        return getFirstMatchingLink(WebLink.MATCH_NAME, name);
    }

    /**
     * Returns the first link found in the page matching the specified criteria.
     **/
    public WebLink getFirstMatchingLink(HTMLElementPredicate predicate, Object criteria) {
        WebLink[] links = getLinks();
        for (WebLink link : links) {
            if (predicate.matchesCriteria(link, criteria)) {
                return link;
            }
        }
        return null;
    }

    /**
     * Returns all links found in the page matching the specified criteria.
     **/
    public WebLink[] getMatchingLinks(HTMLElementPredicate predicate, Object criteria) {
        ArrayList matches = new ArrayList<>();
        WebLink[] links = getLinks();
        for (WebLink link : links) {
            if (predicate.matchesCriteria(link, criteria)) {
                matches.add(link);
            }
        }
        return (WebLink[]) matches.toArray(new WebLink[matches.size()]);
    }

    /**
     * Returns the image found in the page with the specified name.
     **/
    public WebImage getImageWithName(String name) {
        WebImage[] images = getImages();
        for (WebImage image : images) {
            if (HttpUnitUtils.matches(name, image.getName())) {
                return image;
            }
        }
        return null;
    }

    /**
     * Returns the first image found in the page with the specified src attribute.
     **/
    public WebImage getImageWithSource(String source) {
        WebImage[] images = getImages();
        for (WebImage image : images) {
            if (HttpUnitUtils.matches(source, image.getSource())) {
                return image;
            }
        }
        return null;
    }

    /**
     * Returns the first image found in the page with the specified alt attribute.
     **/
    public WebImage getImageWithAltText(String altText) {
        WebImage[] images = getImages();
        for (WebImage image : images) {
            if (HttpUnitUtils.matches(altText, image.getAltText())) {
                return image;
            }
        }
        return null;
    }

    /**
     * Returns the first table in the response which matches the specified predicate and value. Will recurse into any
     * nested tables, as needed.
     *
     * @return the selected table, or null if none is found
     **/
    public WebTable getFirstMatchingTable(HTMLElementPredicate predicate, Object criteria) {
        return getTableSatisfyingPredicate(getTables(), predicate, criteria);
    }

    /**
     * Returns the tables in the response which match the specified predicate and value. Will recurse into any nested
     * tables, as needed.
     *
     * @return the selected tables, or null if none are found
     **/
    public WebTable[] getMatchingTables(HTMLElementPredicate predicate, Object criteria) {
        return getTablesSatisfyingPredicate(getTables(), predicate, criteria);
    }

    /**
     * Returns the first table in the response which has the specified text as the full text of its first non-blank row
     * and non-blank column. Will recurse into any nested tables, as needed.
     *
     * @return the selected table, or null if none is found
     **/
    public WebTable getTableStartingWith(String text) {
        return getFirstMatchingTable(WebTable.MATCH_FIRST_NONBLANK_CELL, text);
    }

    /**
     * Returns the first table in the response which has the specified text as a prefix of the text in its first
     * non-blank row and non-blank column. Will recurse into any nested tables, as needed.
     *
     * @return the selected table, or null if none is found
     **/
    public WebTable getTableStartingWithPrefix(String text) {
        return getFirstMatchingTable(WebTable.MATCH_FIRST_NONBLANK_CELL_PREFIX, text);
    }

    /**
     * Returns the first table in the response which has the specified text as its summary attribute. Will recurse into
     * any nested tables, as needed.
     *
     * @return the selected table, or null if none is found
     **/
    public WebTable getTableWithSummary(String summary) {
        return getFirstMatchingTable(WebTable.MATCH_SUMMARY, summary);
    }

    /**
     * Returns the first table in the response which has the specified text as its ID attribute. Will recurse into any
     * nested tables, as needed.
     *
     * @return the selected table, or null if none is found
     **/
    public WebTable getTableWithID(String ID) {
        return getFirstMatchingTable(WebTable.MATCH_ID, ID);
    }

    /**
     * Returns a copy of the domain object model associated with this page.
     **/
    public Node getDOM() {
        return getRootNode().cloneNode( /* deep */ true);
    }

    // ---------------------------------- Object methods --------------------------------

    @Override
    public String toString() {
        return _baseURL.toExternalForm() + System.lineSeparator() + _rootNode;
    }

    // ---------------------------------- package members --------------------------------

    /**
     * Specifies the root node for this HTML fragment. It will be either an HTMLDocument or an HTMLElement representing
     * a page fragment.
     */
    void setRootNode(Node rootNode) {
        if (_rootNode != null && rootNode != _rootNode) {
            throw new IllegalStateException("The root node has already been defined as " + _rootNode
                    + " and cannot be redefined as " + rootNode);
        }
        _rootNode = rootNode;
        if (rootNode instanceof HTMLDocumentImpl) {
            ((HTMLDocumentImpl) rootNode).setIFramesEnabled(getClientProperties().isIframeSupported());
        }
        clearCaches();
    }

    private void clearCaches() {
        _tables = null;
        _frames = null;
        _blocks = null;
        _updateElements = true;
    }

    /**
     * Returns the base URL for this HTML segment.
     **/
    URL getBaseURL() {
        return _baseURL;
    }

    WebResponse getResponse() {
        return _response;
    }

    /**
     * Returns the domain object model associated with this page, to be used internally.
     **/
    Node getOriginalDOM() {
        return getRootNode();
    }

    HTMLElement getElement(Node node) {
        return (HTMLElement) _registry.getRegisteredElement(node);
    }

    /**
     * Returns the frames found in the page in the order in which they appear.
     **/
    public WebFrame[] getFrames() {
        if (_frames == null) {
            loadElements();
            _frames = (WebFrame[]) _frameList.toArray(new WebFrame[_frameList.size()]);
        }
        return _frames;
    }

    // ---------------------------------- private members --------------------------------

    Node getRootNode() {
        if (_rootNode == null) {
            throw new IllegalStateException("The root node has not been specified");
        }
        return _rootNode;
    }

    /**
     * Returns the table with the specified text in its summary attribute.
     **/
    private WebTable getTableSatisfyingPredicate(WebTable[] tables, HTMLElementPredicate predicate, Object value) {
        for (WebTable table : tables) {
            if (predicate.matchesCriteria(table, value)) {
                return table;
            }
            for (int j = 0; j < table.getRowCount(); j++) {
                for (int k = 0; k < table.getColumnCount(); k++) {
                    TableCell cell = table.getTableCell(j, k);
                    if (cell != null) {
                        WebTable[] innerTables = cell.getTables();
                        if (innerTables.length != 0) {
                            WebTable result = getTableSatisfyingPredicate(innerTables, predicate, value);
                            if (result != null) {
                                return result;
                            }
                        }
                    }
                }
            }
        }
        return null;
    }

    /**
     * Returns the tables which match the specified criteria.
     **/
    private WebTable[] getTablesSatisfyingPredicate(WebTable[] tables, HTMLElementPredicate predicate, Object value) {
        ArrayList matches = new ArrayList<>();
        for (WebTable table : tables) {
            if (predicate.matchesCriteria(table, value)) {
                matches.add(table);
            }
            for (int j = 0; j < table.getRowCount(); j++) {
                for (int k = 0; k < table.getColumnCount(); k++) {
                    TableCell cell = table.getTableCell(j, k);
                    if (cell != null) {
                        WebTable[] innerTables = cell.getTables();
                        if (innerTables.length != 0) {
                            WebTable[] result = getTablesSatisfyingPredicate(innerTables, predicate, value);
                            if (result != null && result.length > 0) {
                                matches.addAll(Arrays.asList(result));
                            }
                        }
                    }
                }
            }
        }
        if (matches.size() > 0) {
            return (WebTable[]) matches.toArray(new WebTable[matches.size()]);
        }
        return null;
    }

    class WebIFrame extends WebFrame implements ContentConcealer {

        public WebIFrame(URL baseURL, Node frameNode, FrameSelector parentFrame) {
            super(_response, baseURL, frameNode, parentFrame);
        }
    }

    /**
     * NoScript Element
     */
    class NoScriptElement extends HTMLElementBase implements ContentConcealer {

        public NoScriptElement(Node node) {
            super(node);
        }

        @Override
        public ScriptableDelegate newScriptable() {
            return null;
        }

        @Override
        public ScriptableDelegate getParentDelegate() {
            return null;
        }
    }

}

hazendaz / httpunit / 636

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous