Returns true if all parameters and values in +match+ are also present in
 +params+.
547605
def params_match?(params, match)
      return true if params == match
      parsed = parse_range_params(params)
      parsed == parsed.merge(parse_range_params(match))
    end
1213308
def _verify_params(self):
        
        reserved_in_use = self._RESERVED_PARAMS.intersection(self.extra_params)
        if reserved_in_use:
            raise ValueError("Using a reserved parameter", reserved_in_use)
947249
public function filtersOnID()
    {
        $regexp = '/^(.*\.)?("|`)?ID("|`)?\s?(=|IN)/';

        foreach ($this->getWhereParameterised($parameters) as $predicate) {
            if (preg_match($regexp, $predicate)) {
                return true;
            }
        }

        return false;
    }
358929
function (params) {

			return _.every(_.keys(params), function (key) { 
				return _.contains(put_params, key); 
			});
		}
275718
def ismatch(self, s):
        
        if self._ismatchfun(s) and self._compiled_pattern.match(s):
            return True
        return False
1284927
def is_complete(self):
        """"""

        return all(p.name in self.values for p in self.parameters if p.required)
621034
def validate_parameters(self):
        """"""
        for p in self.params:
            if p not in self.known_params:
                raise errors.UnknownParameter(p, self.known_params)
343108
def has_param(key)
      code, message, value = @server.call("hasParam", @caller_id, key)
      case code
      when 1
        return value
      when -1
        raise message
      else
        return false
      end
    end
88081
public static boolean hasQueryParam(String param, ContainerRequestContext ctx) {
		return ctx.getUriInfo().getQueryParameters().containsKey(param);
	}
1196834
private function haveParameter($method, $parameter)
    {
        foreach ($method->getParameters() as $param) {
            if ($param->name == $parameter) {
                return true;
            }
        }
        return false;
    }
445865
function checkParams(params, reqParams) {
    if ( reqParams.length < 1 ) {
      return;
    }

    if ( (_.isEmpty(params) || !params) && (reqParams.length > 0) ) {
      throw new Error('Missing parameters: ' + reqParams.join(', '));
    }

    var paramsKeys = _.keys(params);
  
    _.each(reqParams, function(reqParam) {
      if ( paramsKeys.indexOf(reqParam) === -1 ) {
        throw new Error('Missing parameter: ' + reqParam);
      }
    });
  }
601686
def _name_matches(name, matches):
    '''
    
    '''
    for m in matches:
        if name.endswith(m):
            return True
        if name.lower().endswith('_' + m.lower()):
            return True
        if name.lower() == m.lower():
            return True
    return False
546537
private static boolean anyArgumentsMatch(
      List<ParameterPair> changedPairs, List<Parameter> arguments) {
    return changedPairs.stream()
        .anyMatch(
            change ->
                Objects.equals(
                    change.actual().text(), arguments.get(change.formal().index()).text()));
  }
399545
def match(self, p_todo):
        
        for my_tag in config().hidden_item_tags():
            my_values = p_todo.tag_values(my_tag)
            for my_value in my_values:
                if not my_value in (0, '0', False, 'False'):
                    return False

        return True
1098408
public static function only(...$params): bool
    {
        if (static::parametersCount() != count(is_array($params[0]) ? $params[0] : $params)) {
            return false;
        }

        return static::containsParams(...$params);
    }
908089
def has_reg?(name, params = {})
      params = {
        test_for_true_false: true
      }.update(params)
      if params.key?(:enabled_features) || params.key?(:enabled_feature)
        return !!get_registers(params).include?(name)
      else
        params[:enabled_features] = :default
        return !!get_registers(params).include?(name)
      end
    end
529460
def matches?(selector)
      selector.each_pair do |key, value|
        return false unless matcher(key, value).matches?(value)
      end
      true
    end