hazendaz / httpunit / 755

Committed 14 Feb 2026 07:14PM UTC coverage: 80.526%. Remained the same

Build # 755

Build Type

push

github

Committed by

hazendaz

Commit Message

[ci] Fix badge

Run Details

3213 of 4105 branches covered (78.27%)

Branch coverage included in aggregate %.

8245 of 10124 relevant lines covered (81.44%)

0.81 hits per line

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

86.65

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

/*
 * SPDX-License-Identifier: MIT
 * See LICENSE file for details.
 *
 * Copyright 2000-2026 Russell Gold
 * Copyright 2021-2000 hazendaz
 */
package com.meterware.httpunit;

import com.meterware.httpunit.controls.SelectionFormControl;
import com.meterware.httpunit.dom.HTMLControl;
import com.meterware.httpunit.dom.HTMLInputElementImpl;
import com.meterware.httpunit.dom.HTMLSelectElementImpl;
import com.meterware.httpunit.dom.HTMLTextAreaElementImpl;
import com.meterware.httpunit.protocol.ParameterProcessor;
import com.meterware.httpunit.protocol.UploadFileSpec;
import com.meterware.httpunit.scripting.Input;
import com.meterware.httpunit.scripting.ScriptableDelegate;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.w3c.dom.Node;
import org.xml.sax.SAXException;

/**
 * Represents a control in an HTML form.
 **/
public abstract class FormControl extends HTMLElementBase {

    /** The Constant NO_VALUE. */
    static final String[] NO_VALUE = {};

    /** The form. */
    private final WebForm _form;

    /** The control. */
    private HTMLControl _control;

    /** The Constant UNDEFINED_TYPE. */
    public static final String UNDEFINED_TYPE = "undefined";

    /** The Constant BUTTON_TYPE. */
    public static final String BUTTON_TYPE = "button";

    /** The Constant RESET_BUTTON_TYPE. */
    public static final String RESET_BUTTON_TYPE = "reset";

    /** The Constant SUBMIT_BUTTON_TYPE. */
    public static final String SUBMIT_BUTTON_TYPE = "submit";

    /** The Constant IMAGE_BUTTON_TYPE. */
    public static final String IMAGE_BUTTON_TYPE = "image";

    /** The Constant RADIO_BUTTON_TYPE. */
    public static final String RADIO_BUTTON_TYPE = "radio";

    /** The Constant CHECKBOX_TYPE. */
    public static final String CHECKBOX_TYPE = "checkbox";

    /** The Constant TEXT_TYPE. */
    public static final String TEXT_TYPE = "text";

    /** The Constant PASSWORD_TYPE. */
    public static final String PASSWORD_TYPE = "password";

    /** The Constant HIDDEN_TYPE. */
    public static final String HIDDEN_TYPE = "hidden";

    /** The Constant TEXTAREA_TYPE. */
    public static final String TEXTAREA_TYPE = "textarea";

    /** The Constant FILE_TYPE. */
    public static final String FILE_TYPE = "file";

    /** The Constant SINGLE_TYPE. */
    public static final String SINGLE_TYPE = "select-one";

    /** The Constant MULTIPLE_TYPE. */
    public static final String MULTIPLE_TYPE = "select-multiple";

    /**
     * Return the type of the control, as seen from JavaScript.
     *
     * @return the type
     */
    public abstract String getType();

    /**
     * New selection option.
     *
     * @return the scriptable delegate
     */
    static ScriptableDelegate newSelectionOption() {
        return new SelectionFormControl.Option();
    }

    /**
     * Instantiates a new form control.
     *
     * @param form
     *            the form
     */
    FormControl(WebForm form) {
        this(form, newEmptyControlElement(form));
    }

    /**
     * New empty control element.
     *
     * @param form
     *            the form
     *
     * @return the HTML control
     */
    private static HTMLControl newEmptyControlElement(WebForm form) {
        return (HTMLControl) form.getElement().getOwnerDocument().createElement("input");
    }

    /**
     * initialize the given form control from a Webform and a HTMLControl.
     *
     * @param form
     *            the form
     * @param control
     *            the control
     */
    protected FormControl(WebForm form, HTMLControl control) {
        super(control);
        _control = control;
        _form = form;
        supportAttribute("tabindex");
        supportAttribute("disabled");
        // Add all custom attributes
        Set customAttributes = HttpUnitOptions.getCustomAttributes();
        if (customAttributes != null) {
            for (Iterator iter = customAttributes.iterator(); iter.hasNext();) {
                supportAttribute((String) iter.next());
            }
        }
    }

    /**
     * Returns the current value(s) associated with this control. These values will be transmitted to the server if the
     * control is 'successful'.
     *
     * @return the values
     */
    protected abstract String[] getValues();

    /**
     * Returns either a single delegate object or potentially an array of delegates as needed, given the form control.
     * This default implementation returns the scriptable delegate for the control.
     *
     * @return the delegate
     */
    Object getDelegate() {
        return getScriptingHandler();
    }

    /**
     * Gets the form.
     *
     * @return the form
     */
    protected final WebForm getForm() {
        return _form;
    }

    @Override
    public ScriptableDelegate getParentDelegate() {
        return (ScriptableDelegate) getForm().getScriptingHandler();
    }

    /**
     * Returns the values permitted in this control. Does not apply to text or file controls.
     *
     * @return the option values
     */
    public String[] getOptionValues() {
        return NO_VALUE;
    }

    /**
     * Returns the list of values displayed by this control, if any.
     *
     * @return the displayed options
     */
    protected String[] getDisplayedOptions() {
        return NO_VALUE;
    }

    /**
     * Returns true if this control is read-only.
     *
     * @return true, if is read only
     */
    protected boolean isReadOnly() {
        return isDisabled() || _control.getReadOnly();
    }

    /**
     * Returns true if this control is hidden.
     *
     * @return true, if is hidden
     */
    public boolean isHidden() {
        return false;
    }

    /**
     * Sets the disabled.
     *
     * @param disabled
     *            the new disabled
     */
    void setDisabled(boolean disabled) {
        _control.setDisabled(disabled);
    }

    /**
     * Returns true if this control is disabled, meaning that it will not send a value to the server as part of a
     * request.
     *
     * @return true, if is disabled
     */
    public boolean isDisabled() {
        return _control.getDisabled();
    }

    /**
     * Returns true if this control accepts free-form text.
     *
     * @return true, if is text control
     */
    boolean isTextControl() {
        return false;
    }

    /**
     * Returns true if only one control of this kind with this name can have a value. This is true for radio buttons.
     *
     * @return true, if is exclusive
     */
    boolean isExclusive() {
        return false;
    }

    /**
     * Returns true if a single control can have multiple values.
     *
     * @return true, if is multi valued
     */
    protected boolean isMultiValued() {
        return false;
    }

    /**
     * Returns true if this control accepts a file for upload.
     *
     * @return true, if is file parameter
     */
    boolean isFileParameter() {
        return false;
    }

    /**
     * Adds the values.
     *
     * @param processor
     *            the processor
     * @param characterSet
     *            the character set
     *
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     */
    protected abstract void addValues(ParameterProcessor processor, String characterSet) throws IOException;

    /**
     * Remove any required values for this control from the list, throwing an exception if they are missing.
     *
     * @param values
     *            the values
     */
    void claimRequiredValues(List values) {
    }

    /**
     * Sets this control to the next compatible value from the list, removing it from the list.
     *
     * @param values
     *            the values
     */
    void claimValue(List values) {
    }

    /**
     * Sets this control to the next compatible value from the list, removing it from the list.
     *
     * @param values
     *            the values
     */
    protected void claimUniqueValue(List values) {
    }

    /**
     * Specifies a file to be uploaded via this control.
     *
     * @param files
     *            the files
     */
    void claimUploadSpecification(List files) {
    }

    /**
     * Resets this control to its initial value.
     **/
    protected void reset() {
        _control.reset();
    }

    /**
     * Toggles the value of this control.
     */
    public void toggle() {
        throw new FormParameter.IllegalCheckboxParameterException(getName(), "toggleCheckbox");
    }

    /**
     * Sets the state of this boolean control.
     *
     * @param state
     *            the new state
     */
    public void setState(boolean state) {
        throw new FormParameter.IllegalCheckboxParameterException(getName(), "setCheckbox");
    }

    /**
     * Performs the 'onChange' event defined for this control.
     *
     * @deprecated since 1.7 use doOnChangeEvent instead
     */
    @Deprecated
    protected void sendOnChangeEvent() {
        doOnChangeEvent();
    }

    /**
     * Performs the 'onchange' event defined for this control.
     *
     * @return true, if successful
     */
    protected boolean doOnChangeEvent() {
        return handleEvent("onchange");
    }

    /**
     * Performs the 'onClick' event defined for this control.
     *
     * @deprecated since 1.7 use doOnClickEvent instead
     */
    @Deprecated
    protected void sendOnClickEvent() {
        doOnClickEvent();
    }

    /**
     * Performs the 'onClick' event defined for this control.
     *
     * @return true, if successful
     */
    protected boolean doOnClickEvent() {
        return handleEvent("onclick");
    }

    /**
     * Performs the 'onMouseUp' event defined for this control.
     *
     * @deprecated since 1.7 use doOnMouseUpEvent instead
     */
    @Deprecated
    protected void sendOnMouseUpEvent() {
        doOnMouseUpEvent();
    }

    /**
     * Performs the 'onMouseUp' event defined for this control.
     *
     * @return true, if successful
     */
    protected boolean doOnMouseUpEvent() {
        return handleEvent("onmouseup");
    }

    /**
     * Performs the 'onMouseDown' event defined for this control.
     *
     * @deprecated since 1.7 use doOnMouseDownEvent instead
     */
    @Deprecated
    protected void sendOnMouseDownEvent() {
        doOnMouseDownEvent();
    }

    /**
     * Performs the 'onMouseDown' event defined for this control.
     *
     * @return true, if successful
     */
    protected boolean doOnMouseDownEvent() {
        return handleEvent("onmousedown");
    }

    /**
     * Creates and returns a scriptable object for this control. Subclasses should override this if they use a different
     * implementation of Scriptable.
     */
    @Override
    public ScriptableDelegate newScriptable() {
        return new Scriptable();
    }

    /**
     * Returns the value of this control in the form. If no value is specified, defaults to the empty string.
     *
     * @return the value attribute
     */
    protected String getValueAttribute() {
        return "";
    }

    /**
     * Sets the value of this control in the form.
     *
     * @param value
     *            the new value attribute
     */
    protected void setValueAttribute(String value) {
    }

    /**
     * Removes the specified required value from the list of values, throwing an exception if it is missing.
     *
     * @param values
     *            the values
     * @param value
     *            the value
     */
    protected final void claimValueIsRequired(List values, final String value) {
        if (!values.contains(value)) {
            throw new MissingParameterValueException(getName(), value,
                    (String[]) values.toArray(new String[values.size()]));
        }
        values.remove(value);
    }

    /**
     * Gets the control element tags.
     *
     * @return the control element tags
     */
    static String[] getControlElementTags() {
        return new String[] { "textarea", "select", "button", "input" };
    }

    /**
     * return the FormControl for the given parameter node in a form.
     *
     * @param form
     *            - the form in which the parameter is defined
     * @param node
     *            - the node in which the parameter is defined
     *
     * @return the form control
     */
    static FormControl newFormParameter(WebForm form, Node node) {
        if (node.getNodeType() != Node.ELEMENT_NODE) {
            return null;
        }
        if (node.getNodeName().equalsIgnoreCase("textarea")) {
            return new TextAreaFormControl(form, (HTMLTextAreaElementImpl) node);
        }
        if (node.getNodeName().equalsIgnoreCase("select")) {
            return new SelectionFormControl(form, (HTMLSelectElementImpl) node);
        }
        if (node.getNodeName().equalsIgnoreCase("button")) {
            HTMLControl control = (HTMLControl) node;
            final String type = control.getType();
            if (type.equalsIgnoreCase(SUBMIT_BUTTON_TYPE)) {
                return new SubmitButton(form, control);
            }
            if (type.equalsIgnoreCase(RESET_BUTTON_TYPE)) {
                return new ResetButton(form, control);
            }
            return new Button(form, control);
        }
        if (!node.getNodeName().equalsIgnoreCase("input")) {
            return null;
        }
        HTMLInputElementImpl element = (HTMLInputElementImpl) node;
        final String type = element.getType();
        if (type.equalsIgnoreCase(TEXT_TYPE)) {
            return new TextFieldFormControl(form, element);
        }
        if (type.equalsIgnoreCase(PASSWORD_TYPE)) {
            return new PasswordFieldFormControl(form, element);
        }
        if (type.equalsIgnoreCase(HIDDEN_TYPE)) {
            return new HiddenFieldFormControl(form, element);
        }
        if (type.equalsIgnoreCase(RADIO_BUTTON_TYPE)) {
            return new RadioButtonFormControl(form, element);
        }
        if (type.equalsIgnoreCase(CHECKBOX_TYPE)) {
            return new CheckboxFormControl(form, element);
        }
        if (type.equalsIgnoreCase(SUBMIT_BUTTON_TYPE) || type.equalsIgnoreCase(IMAGE_BUTTON_TYPE)) {
            return new SubmitButton(form, element);
        }
        if (type.equalsIgnoreCase(BUTTON_TYPE)) {
            return new Button(form, (HTMLControl) node);
        }
        if (type.equalsIgnoreCase(RESET_BUTTON_TYPE)) {
            return new ResetButton(form, (HTMLControl) node);
        }
        if (type.equalsIgnoreCase(FILE_TYPE)) {
            return new FileSubmitFormControl(form, element);
        }
        return new TextFieldFormControl(form, element);
    }

    /**
     * Empty if null.
     *
     * @param value
     *            the value
     *
     * @return the string
     */
    protected String emptyIfNull(String value) {
        return value == null ? "" : value;
    }

    /**
     * implementation of Scriptable input elements.
     */
    public class Scriptable extends HTMLElementScriptable implements Input {

        /**
         * get my Name
         *
         * @return the name of this scriptable
         */
        @Override
        public String getName() {
            return FormControl.this.getName();
        }

        /**
         * get my ID
         *
         * @return the id of this scriptable
         */
        @Override
        public String getID() {
            return FormControl.this.getID();
        }

        /**
         * construct a Scriptable.
         */
        public Scriptable() {
            super(FormControl.this);
        }

        /**
         * get the given property
         *
         * @param propertyName
         *            - the name of the property to get
         */
        @Override
        public Object get(String propertyName) {
            if (propertyName.equalsIgnoreCase("name")) {
                return FormControl.this.getName();
            }
            if (propertyName.equalsIgnoreCase("type")) {
                return FormControl.this.getType();
            }
            return super.get(propertyName);
        }

        /**
         * set the given property to the given value
         *
         * @param propertyName
         *            - the property to set
         * @param value
         *            - the value to use
         */
        @Override
        public void set(String propertyName, Object value) {
            if (propertyName.equalsIgnoreCase("value")) {
                setValueAttribute(value.toString());
            } else if (propertyName.equalsIgnoreCase("disabled")) {
                setDisabled(value instanceof Boolean && ((Boolean) value).booleanValue());
            } else {
                super.set(propertyName, value);
            }
        }

        /**
         * set the given attribute to the given value
         *
         * @param attributeName
         *            - the name of the attribute to set
         * @param value
         *            - the value to use
         */
        @Override
        public void setAttribute(String attributeName, Object value) {
            // Value set by JavaScript, make sure attribute is supported
            supportAttribute(attributeName);
            super.setAttribute(attributeName, value);
        }

        /**
         * allow calling click for this control
         */
        @Override
        public void click() throws IOException, SAXException {
            // TODO check whether the empty body of this method was correct
            // call onclick event handler
            HTMLElement element = this.get_element();
            if (element instanceof FormControl) {
                FormControl control = (FormControl) element;
                control.sendOnClickEvent();
            }
        }

        /**
         * simulate blur.
         */
        public void blur() {
            handleEvent("onblur");
        }

        /**
         * simulate focus;.
         */
        public void focus() {
            handleEvent("onfocus");
        }

        /**
         * allow firing a sendOnChangeEvent
         */
        @Override
        public void sendOnChangeEvent() {
            // TODO check why the test for this does not work although
            // the javascript function call is done in the corresponding testcase
            // testCallOnChange()
            HTMLElement element = this.get_element();
            if (element instanceof FormControl) {
                FormControl control = (FormControl) element;
                control.sendOnChangeEvent();
            }
        }

    }

}

abstract class BooleanFormControl extends FormControl {

    private String[] _displayedValue;

    private HTMLInputElementImpl _element;

    @Override
    public ScriptableDelegate newScriptable() {
        return new Scriptable();
    }

    class Scriptable extends FormControl.Scriptable {

        @Override
        public Object get(String propertyName) {
            if (propertyName.equalsIgnoreCase("value")) {
                return getQueryValue();
            }
            if (propertyName.equalsIgnoreCase("checked")) {
                return isChecked() ? Boolean.TRUE : Boolean.FALSE;
            }
            if (propertyName.equalsIgnoreCase("defaultchecked")) {
                return _element.getDefaultChecked() ? Boolean.TRUE : Boolean.FALSE;
            }
            return super.get(propertyName);
        }

        @Override
        public void set(String propertyName, Object value) {
            if (propertyName.equalsIgnoreCase("checked")) {
                setChecked(value instanceof Boolean && ((Boolean) value).booleanValue());
            } else {
                super.set(propertyName, value);
            }
        }
    }

    public BooleanFormControl(WebForm form, HTMLInputElementImpl element) {
        super(form, element);
        _element = element;
        _displayedValue = new String[] { readDisplayedValue(element) };
    }

    private String readDisplayedValue(Node node) {
        Node nextSibling = node.getNextSibling();
        while (nextSibling != null && nextSibling.getNodeType() != Node.TEXT_NODE
                && nextSibling.getNodeType() != Node.ELEMENT_NODE) {
            nextSibling = nextSibling.getNextSibling();
        }
        if (nextSibling == null || nextSibling.getNodeType() != Node.TEXT_NODE) {
            return "";
        }
        return nextSibling.getNodeValue();
    }

    boolean isChecked() {
        return _element.getChecked();
    }

    @Override
    protected String getValueAttribute() {
        return emptyIfNull(_element.getValue());
    }

    @Override
    protected void setValueAttribute(String value) {
        _element.setValue(value);
    }

    /**
     * Sets the checked.
     *
     * @param checked
     *            the new checked
     */
    public void setChecked(boolean checked) {
        _element.setChecked(checked);
    }

    /**
     * Returns the current value(s) associated with this control. These values will be transmitted to the server if the
     * control is 'successful'.
     **/
    @Override
    public String[] getValues() {
        return isChecked() ? toArray(getQueryValue()) : NO_VALUE;
    }

    /**
     * Returns the values permitted in this control.
     **/
    @Override
    public String[] getOptionValues() {
        return isReadOnly() && !isChecked() ? NO_VALUE : toArray(getQueryValue());
    }

    @Override
    protected String[] getDisplayedOptions() {
        return _displayedValue;
    }

    @Override
    protected void addValues(ParameterProcessor processor, String characterSet) throws IOException {
        if (isChecked() && !isDisabled()) {
            processor.addParameter(getName(), getQueryValue(), characterSet);
        }
    }

    /**
     * Remove any required values for this control from the list, throwing an exception if they are missing.
     **/
    @Override
    void claimRequiredValues(List values) {
        if (isValueRequired()) {
            claimValueIsRequired(values, getQueryValue());
        }
    }

    /**
     * Checks if is value required.
     *
     * @return true, if is value required
     */
    protected boolean isValueRequired() {
        return isReadOnly() && isChecked();
    }

    abstract String getQueryValue();

    private String[] toArray(String value) {
        return new String[] { value };
    }
}

class CheckboxFormControl extends BooleanFormControl {

    @Override
    public String getType() {
        return CHECKBOX_TYPE;
    }

    public CheckboxFormControl(WebForm form, HTMLInputElementImpl element) {
        super(form, element);
    }

    @Override
    protected void claimUniqueValue(List values) {
        if (isValueRequired()) {
            return;
        }
        setState(values.contains(getQueryValue()));
        if (isChecked()) {
            values.remove(getQueryValue());
        }
    }

    @Override
    String getQueryValue() {
        final String value = getValueAttribute();
        return value.isEmpty() ? "on" : value;
    }

    /**
     * Toggles the value of this control.
     */
    @Override
    public void toggle() {
        setState(!isChecked());
    }

    /**
     * Sets the state of this boolean control. Triggers the 'onclick' event if the state has changed.
     */
    @Override
    public void setState(boolean state) {
        boolean wasChecked = isChecked();
        setChecked(state);
        if (isChecked() != wasChecked) {
            sendOnClickEvent();
        }
    }
}

abstract class TextFormControl extends FormControl {

    public TextFormControl(WebForm form, HTMLControl control) {
        super(form, control);
    }

    /**
     * Returns the current value(s) associated with this control. These values will be transmitted to the server if the
     * control is 'successful'.
     **/
    @Override
    public String[] getValues() {
        return new String[] { getValue() };
    }

    abstract protected String getDefaultValue();

    abstract protected String getValue();

    abstract protected void setValue(String value);

    /**
     * Returns true to indicate that this control accepts free-form text.
     **/
    @Override
    public boolean isTextControl() {
        return true;
    }

    @Override
    public ScriptableDelegate newScriptable() {
        return new Scriptable();
    }

    @Override
    protected void addValues(ParameterProcessor processor, String characterSet) throws IOException {
        if (!isDisabled() && getName().length() > 0) {
            processor.addParameter(getName(), getValues()[0], characterSet);
        }
    }

    /**
     * claim values and fire onChange Event if a change occured
     *
     * @param values
     *            - the list of values
     */
    @Override
    void claimValue(List values) {
        if (isReadOnly()) {
            return;
        }

        String oldValue = getValue();
        if (values.isEmpty()) {
            setValue("");
        } else {
            setValue((String) values.get(0));
            values.remove(0);
        }
        boolean same = oldValue == null && getValue() == null;
        if (oldValue != null) {
            same = oldValue.equals(getValue());
        }
        if (!same) {
            sendOnChangeEvent();
        }
    }

    @Override
    void claimRequiredValues(List values) {
        if (isReadOnly()) {
            claimValueIsRequired(values);
        }
    }

    protected void claimValueIsRequired(List values) {
        claimValueIsRequired(values, getDefaultValue());
    }

    class Scriptable extends FormControl.Scriptable {

        @Override
        public Object get(String propertyName) {
            if (propertyName.equalsIgnoreCase("value")) {
                return getValue();
            }
            if (propertyName.equalsIgnoreCase("defaultValue")) {
                return getDefaultValue();
            }
            return super.get(propertyName);
        }

        @Override
        public void set(String propertyName, Object value) {
            if (!propertyName.equalsIgnoreCase("value")) {
                super.set(propertyName, value);
            } else if (value instanceof Number) {
                setValue(HttpUnitUtils.trimmedValue((Number) value));
            } else {
                setValue(value == null ? null : value.toString());
            }
        }
    }
}

class TextFieldFormControl extends TextFormControl {

    private HTMLInputElementImpl _element;

    @Override
    public String getType() {
        return TEXT_TYPE;
    }

    public TextFieldFormControl(WebForm form, HTMLInputElementImpl element) {
        super(form, element);
        _element = element;
        supportAttribute("maxlength");
    }

    @Override
    protected String getDefaultValue() {
        return _element.getDefaultValue();
    }

    @Override
    protected String getValue() {
        return emptyIfNull(_element.getValue());
    }

    @Override
    protected void setValue(String value) {
        _element.setValue(value);
    }
}

class PasswordFieldFormControl extends TextFieldFormControl {

    @Override
    public String getType() {
        return PASSWORD_TYPE;
    }

    public PasswordFieldFormControl(WebForm form, HTMLInputElementImpl element) {
        super(form, element);
    }
}

/**
 * a hidden text field
 */
class HiddenFieldFormControl extends TextFieldFormControl {

    @Override
    public String getType() {
        return HIDDEN_TYPE;
    }

    public HiddenFieldFormControl(WebForm form, HTMLInputElementImpl element) {
        super(form, element);
    }

    @Override
    void claimRequiredValues(List values) {
        claimValueIsRequired(values);
    }

    @Override
    void claimValue(List values) {
    }

    @Override
    public boolean isHidden() {
        return true;
    }
}

class TextAreaFormControl extends TextFormControl {

    private HTMLTextAreaElementImpl _element;

    public TextAreaFormControl(WebForm form, HTMLTextAreaElementImpl element) {
        super(form, element);
        _element = element;
    }

    @Override
    public String getType() {
        return TEXTAREA_TYPE;
    }

    @Override
    protected String getDefaultValue() {
        return _element.getDefaultValue();
    }

    @Override
    protected String getValue() {
        return _element.getValue();
    }

    @Override
    protected void setValue(String value) {
        _element.setValue(value);
    }

}

/**
 * a control for File submit
 */
class FileSubmitFormControl extends FormControl {

    /**
     * accessor for the type
     *
     * @return the constant FILE_TYPE
     */
    @Override
    public String getType() {
        return FILE_TYPE;
    }

    private UploadFileSpec _fileToUpload;

    @Override
    public ScriptableDelegate newScriptable() {
        return new Scriptable();
    }

    class Scriptable extends FormControl.Scriptable {

        @Override
        public Object get(String propertyName) {
            if (propertyName.equalsIgnoreCase("value")) {
                return getSelectedName();
            }
            return super.get(propertyName);
        }

    }

    public FileSubmitFormControl(WebForm form, HTMLInputElementImpl node) {
        super(form, node);
    }

    /**
     * Returns true if this control accepts a file for upload.
     **/
    @Override
    public boolean isFileParameter() {
        return true;
    }

    /**
     * Returns the name of the selected file, if any.
     */
    @Override
    public String[] getValues() {
        return new String[] { getSelectedName() };
    }

    private String getSelectedName() {
        return _fileToUpload == null ? "" : _fileToUpload.getFileName();
    }

    /**
     * Specifies a number of file upload specifications for this control.
     **/
    @Override
    void claimUploadSpecification(List files) {
        if (files.isEmpty()) {
            _fileToUpload = null;
        } else {
            _fileToUpload = (UploadFileSpec) files.get(0);
            files.remove(0);
        }
    }

    @Override
    protected void addValues(ParameterProcessor processor, String characterSet) throws IOException {
        if (!isDisabled() && _fileToUpload != null) {
            processor.addFile(getName(), _fileToUpload);
        }
    }
}

// ============================= exception class MissingParameterValueException ======================================

/**
 * This exception is thrown on an attempt to remove a required value from a form parameter.
 **/
class MissingParameterValueException extends IllegalRequestParameterException {

    private static final long serialVersionUID = 1L;

    MissingParameterValueException(String parameterName, String missingValue, String[] proposed) {
        _parameterName = parameterName;
        _missingValue = missingValue;
        _proposedValues = proposed;
    }

    @Override
    public String getMessage() {
        StringBuilder sb = new StringBuilder(HttpUnitUtils.DEFAULT_TEXT_BUFFER_SIZE);
        sb.append("Parameter '").append(_parameterName).append("' must have the value '");
        sb.append(_missingValue).append("'. Attempted to set it to: { ");
        for (int i = 0; i < _proposedValues.length; i++) {
            if (i != 0) {
                sb.append(", ");
            }
            sb.append(_proposedValues[i]);
        }
        sb.append(" }");
        return sb.toString();
    }

    private String _parameterName;
    private String _missingValue;
    private String[] _proposedValues;
}

hazendaz / httpunit / 755

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