If the clear checkbox is checked returns the configured empty value,
        completely ignoring the original input.
549258
def value_from_datadict(self, data, files, name):
        
        clear = self.checkbox.value_from_datadict(data, files, self.clear_checkbox_name(name))
        if clear:
            return self.empty_value
        return self.widget.value_from_datadict(data, files, name)
790319
private void handleHidden(FormInput input) {
		String text = input.getInputValues().iterator().next().getValue();
		if (null == text || text.length() == 0) {
			return;
		}
		WebElement inputElement = browser.getWebElement(input.getIdentification());
		JavascriptExecutor js = (JavascriptExecutor) browser.getWebDriver();
		js.executeScript("arguments[0].setAttribute(arguments[1], arguments[2]);", inputElement,
				"value", text);
	}
487945
static function checkBox($name, $bit, $attr = array(), $val = true)
    {
        if ($bit == "true" || $bit == 1)
            $attr["checked"] = "true";

        $attr = array_merge(
            array(
                "type" => "checkbox",
            ),
            $attr
        );

        self::input($name, $val, $attr);
    }
311949
def empty(cls: Type[BoardT], *, chess960: bool = False) -> BoardT:
        """"""
        return cls(None, chess960=chess960)
1313828
def check_checkbox(self, value):
    """"""
    check_box = find_field(world.browser, 'checkbox', value)
    assert check_box, "Cannot find checkbox '{}'.".format(value)
    if not check_box.is_selected():
        check_box.click()
312759
private void precheckStateAllNull() throws IllegalStateException {
        if ((doubleValue != null) || (doubleArray != null)
            || (longValue != null) || (longArray != null)
            || (stringValue != null) || (stringArray != null)
            || (map != null)) {
            throw new IllegalStateException("Expected all properties to be empty: " + this);
        }
    }
424317
def assert_checked_checkbox(self, value):
    """"""
    check_box = find_field(world.browser, 'checkbox', value)
    assert check_box, "Cannot find checkbox '{}'.".format(value)
    assert check_box.is_selected(), "Check box should be selected."
971610
function getCheckbox(checked) {
  return checked ? utils.chalk.green(utils.figures.radioOn) : utils.figures.radioOff;
}
434708
def _check_default(value, parameter, default_chars):
    ''''''
    # not using a set here because it fails when value is unhashable
    if value in default_chars:
        if parameter.default is inspect.Parameter.empty:
            raise ValueError('Value was empty, but no default value is given in view function for parameter: {} ({})'.format(parameter.position, parameter.name))
        return parameter.default
    return value
356814
public String isChecked(String value1, String value2) {

        if ((value1 == null) || (value2 == null)) {
            return "";
        }

        if (value1.trim().equalsIgnoreCase(value2.trim())) {
            return "checked";
        }

        return "";
    }
49124
@Nonnull
  @Nonempty
  public static String getCheckBoxHiddenFieldName (@Nonnull @Nonempty final String sFieldName)
  {
    ValueEnforcer.notEmpty (sFieldName, "FieldName");
    return DEFAULT_CHECKBOX_HIDDEN_FIELD_PREFIX + sFieldName;
  }
67964
function () {
            var config   = this._conf()
              , meta     = this._meta()
              , spec     = this._spec()
              , value    = config.value
              , truthMap = getOrNull( spec, 'truthMap' )
              , checked  = truthMap 
                    ? truthMap[ "true" ] === value
                    : value;
            
            if ( meta.isHidden ) return null;

            return (
                React.createElement("input", {
                    id: config.fieldID, 
                    type: "checkbox", 
                    className: "generated-checkbox-field", 
                    name: spec.name, 
                    checked: checked, 
                    readOnly: meta.isReadOnly || meta.isDisabled, 
                    onChange: this.handleOnChange, 
                    onBlur: this.handleEvent( 'blur'), 
                    onFocus: this.handleEvent( 'focus'), 
                    onKeyPress: this.handleEvent( 'keypress')})
            );
        }
105418
public static String nullifyBadInput(String input)
    {
        if (input != null)
        {
            if (input.matches(emptyRegex))
            {
                return null;
            }
            return input.trim();
        }
        return null;
    }
707669
@SuppressWarnings("rawtypes")
    public boolean isInputEmpty() {

        final Object fieldValue = getValue();
        final Class<?> fieldType = getType();

        if(fieldValue == null) {
            return true;

        } else if(Collection.class.isAssignableFrom(fieldType) && ((Collection) fieldValue).isEmpty()) {
            return true;

        } else if(fieldType.isArray()) {

            Class<?> componentType = fieldType.getComponentType();
            int length = Utils.getArraySize(fieldValue, componentType);
            if(length > 0) {
                return false;
            }

            return true;

        }

        return super.isInputEmpty();
    }
865979
function () {
            var possibleVals = result(this, 'possibleVals');
            var key;
            var i = 0;
            var possibleVal;
            var $checkbox;
            var isSelected;
            var $inputWrapper = this.getInputWrapper().empty();

            for (key in possibleVals) {
                if (possibleVals.hasOwnProperty(key)) {
                    possibleVal = this._parsePossibleVal(possibleVals, key);
                    isSelected = this.isSelected(possibleVal.value);
                    $checkbox = this._renderInput(possibleVal, isSelected, i);
                    $inputWrapper.append($checkbox);
                    i++;
                }
            }
            return this;
        }
786280
public String fixedCheckbox (String name, boolean value)
    {
        StringBuilder buf = new StringBuilder();
        buf.append("<input type=\"checkbox\"");
        buf.append(" name=\"").append(name).append("\"");
        if (value) {
            buf.append(_useXHTML ? " checked=\"checked\"" : " checked");
        }
        buf.append(getCloseBrace());
        return buf.toString();
    }
371487
function checkOutput() {
        // Note that we shift the output array here.
        const getNextOutputBlock = () => R.defaultTo('', output.shift());

        let isFound = false;

        do {
          isFound = R.contains(text, getNextOutputBlock());
        } while (!isFound && !R.isEmpty(output));

        if (isFound) {
          clearInterval(intervalID);
          resolve();
        }
      }