Checks that form hidden field with specified id|name has specified value.

@Then /^the "(?P<field>(?:[^"]|\\")*)" hidden field should contain "(?P<value>(?:[^"]|\\")*)"$/
769856
public function hiddenFieldValueEquals($field, $value)
    {
        $node = $this->findHiddenField($field);
        $actual = $node->getValue();
        $regex = '/^' . preg_quote($value, '/') . '/ui';

        if (!preg_match($regex, $actual)) {
            $message = sprintf('The hidden field "%s" value is "%s", but "%s" expected.', $field, $actual, $value);

            throw new ExpectationException($message, $this->getSession());
        }
    }
1200960
function(fieldName) {
                return _.has(this.filterableFields, fieldName) && !_.isNull(this.filterableFields[fieldName].value);
            }
209375
public function hidden($name = NULL, String $value = NULL)
    {
        $name  = $this->settings['attr']['name' ] ?? $name ;
        $value = $this->settings['attr']['value'] ?? $value;

        $this->settings['attr'] = [];

        $hiddens = NULL;
        
        if( is_array($name) ) foreach( $name as $key => $val )
        {
            $hiddens .= $this->createHiddenElement($key, $val);
        }
        else
        {
            $hiddens =  $this->createHiddenElement($name, $value);
        }

        $this->outputElement .= $hiddens;

        return $this;
    }
901014
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME_TYPES:
      return isSetName_types();
    case VALUE_TYPES:
      return isSetValue_types();
    case DEFAULT_NAME_TYPE:
      return isSetDefault_name_type();
    case DEFAULT_VALUE_TYPE:
      return isSetDefault_value_type();
    }
    throw new IllegalStateException();
  }
739242
public static void checkNotEmpty(Object value, String fieldName) throws AlipayApiException {
		if(value==null){
            throw new AlipayApiException(ERROR_CODE_ARGUMENTS_MISS,
                "client-error:Missing Required Arguments:" + fieldName + "");
		}
		if(value instanceof String){
			if(((String) value).trim().length()==0){
                throw new AlipayApiException(ERROR_CODE_ARGUMENTS_MISS,
                    "client-error:Missing Required Arguments:" + fieldName + "");
			}
		}
	}
727530
private JBBPTokenizerException checkFieldName(final String name, final int position) {
    if (name != null) {
      final String normalized = JBBPUtils.normalizeFieldNameOrPath(name);
      if (normalized.indexOf('.') >= 0) {
        return new JBBPTokenizerException("Field name must not contain '.' char", position);
      }

      if (normalized.length() > 0) {
        if (normalized.equals("_")
            || normalized.equals("$$")
            || normalized.startsWith("$")
            || Character.isDigit(normalized.charAt(0))
        ) {
          return new JBBPTokenizerException("'" + name + "' can't be field name", position);
        }

        for (int i = 1; i < normalized.length(); i++) {
          final char chr = normalized.charAt(i);
          if (chr != '_' && !Character.isLetterOrDigit(chr)) {
            return new JBBPTokenizerException("Char '" + chr + "' not allowed in name", position);
          }
        }
      }
    }
    return null;
  }
1084255
private boolean hidden(String className) {
	className = removeTemplate(className);
	ClassInfo ci = classnames.get(className);
	return ci != null ? ci.hidden : optionProvider.getOptionsFor(className).matchesHideExpression(className);
    }
346236
protected function createHidden($name, $value = null)
    {
        $field = Former::hidden($this->inputName($name))->class('input-'.$name);
        if ($value) {
            if (!is_scalar($value)) {
                $value = json_encode($value);
            }
            $field->forceValue($value);
        }

        return $field->render();
    }
248249
private void addHiddenField(Panel form, String fieldName, String fieldValue) {

        Hidden inputField = new Hidden();
        inputField.setName(fieldName);
        inputField.setValue(fieldValue);
        form.add(inputField);
    }
856142
public boolean containsFieldName(String field) {
    for (SortElement e : elements) {
      if (e.getName().equals(field)) {
        return true;
      }
    }
    return false;
  }
356368
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME:
      return isSetName();
    case DATA_TYPE:
      return isSetDataType();
    case ENCODING:
      return isSetEncoding();
    case OTHER_ARGS:
      return isSetOtherArgs();
    }
    throw new IllegalStateException();
  }
997982
@Override
    public boolean hasValue(String paramName) {
        return criterias.containsKey(paramName) || LIMIT_NAME.equals(paramName)
                || OFFSET_NAME.equals(paramName);
    }
661842
def isHiddenName(astr):
    
    if astr is not None and len(astr) > 2 and astr.startswith('_') and \
       astr.endswith('_'):
        return True
    else:
        return False
444635
def inputs(form_args):
    
    element = []
    for name, value in form_args.items():
        element.append(
            '<input type="hidden" name="{}" value="{}"/>'.format(name, value))
    return "\n".join(element)
287274
protected static void printHiddenField(ChainWriter out, int indent, String name, String value) throws IOException {
		for(int c=0;c<indent;c++) out.print("  ");
		out.print("<input type='hidden' name='").encodeXmlAttribute(name).print("' value='").encodeXmlAttribute(value).print("' />\n");
	}

	public List<UploadedFile> getUploadedFiles() {
		if(reqUploadedFiles==null) Collections.emptyList();
		return Collections.unmodifiableList(reqUploadedFiles);
	}

	/**
	 * Gets a file that was uploaded given its ID.  The authentication
	 * credentials for this request must match those of the provided ID.
	 *
	 * @return  the owner of the object
	 * @return  the <code>UploadedFile</code> or <code>null</code> if not found
	 *
	 * @exception  SecurityException  if the ID is not assigned to the person logged in
	 */
	public static UploadedFile getUploadedFile(WebSiteUser owner, long id, ServletContext context, LoggerAccessor loggerAccessor) throws SecurityException {
		synchronized(uploadedFiles) {
			UploadedFile uf=uploadedFiles.get(Long.valueOf(id));
			if(uf!=null) {
				if(uf.getOwner().equals(owner)) return uf;
				else {
					loggerAccessor.getLogger(
						context,
						WebSiteRequest.class.getName()
					).log(
						Level.SEVERE,
						"UploadedFile found, but owner doesn''t match: uf.getOwner()=\"{0}\", owner=\"{1}\".",
						new Object[] {
							uf.getOwner(),
							owner
						}
					);
				}
			}
			return null;
		}
	}

	@Override
	public File rename(File file) {
		try {
			while(true) {
				File newFile=new File(getFileUploadDirectory(getServletContext()), String.valueOf(getNextID()));
				if(!newFile.exists()) return newFile;
			}
		} catch(IOException err) {
			throw new WrappedException(err, new Object[] {"file.getPath()="+file.getPath()});
		}
	}

	/**
	 * Gets the person who is logged in or <code>null</code> if no login is performed for this request.
	 *
	 * @exception LoginException if an invalid login attempt is made or the user credentials are not found
	 */
	public WebSiteUser getWebSiteUser(HttpServletResponse resp) throws IOException, SQLException, LoginException {
		return null;
	}

	/**
	 * Determines if the user is currently logged in.
	 */
	public boolean isLoggedIn() throws IOException, SQLException {
		try {
			return getWebSiteUser(null)!=null;
		} catch(LoginException err) {
			return false;
		}
	}

	/**
	 * Logs out the current user or does nothing if not logged in.
	 */
	public void logout(HttpServletResponse resp) {
	}
563379
private static InputElement createHiddenInput(String name, String value) {

        InputElement input = Document.get().createHiddenInputElement();
        input.setName(name);
        input.setValue(value);
        return input;
    }
905340
function (name, validation) {
		if (name == null && validation == null) {
			this.isRequired = false;
			return this;
		}

		return this.field(name).validate(validation).optional();
	}