Check if parameters are usable
Mainly if parameters are still decorators it will break the injection
@param $params
175562
protected function checkParams($params)
    {
        foreach ($params as $type) {
            if ($type instanceof Decorator) {
                $this->errors[] = "Parameter is not well instantiated [" . (string)$type . "]";
            }
        }
    }
506889
protected function setParams(array $params) {
		parent::setParams($params);
		$ref = $this->relative ? str_replace('(%s)://', '(?:(%s)://)?', $this->ref) : $this->ref;
		$this->ref = sprintf($ref, implode('|', $this->protocols));
	}
675026
protected function setOutputColorVisibility(array $params)
    {
        if ($this->hasParameter($params, '-nc') || $this->hasParameter($params, '--no-color')) {
            $this->hideColors = true;
        }
    }
1239721
protected function setParams($params)
    {
        $this->params = $this->default_params;
        foreach ($params as $name => $value) {
            $method = 'set' . str_replace(' ', '', ucwords(str_replace('_', ' ', strtolower($name))));
            if (!method_exists($this, $method)) {
                throw new Exception\InvalidArgumentException(__METHOD__ . " Parameter '$name' does not exists.");
            }
            $this->$method($value);
        }
    }
301624
public static function maybe_split_parameters( $params ) {
		if ( ! \is_array( $params ) ) {
			// We can safely cast to an array here, as long as $params convertible to a string.
			$params = (array) \preg_split( self::RE_PARAMETER_SPLITTING, $params, -1, PREG_SPLIT_NO_EMPTY );
		}

		return $params;
	}
551685
private function saveInputParams($params){
		foreach($params as $param => $value){
			$var = "_" . $param;

			if(!isset($this->{$var}) || !is_null($this->{$var})){
				$this->{$var} = $value;
			}
		}

		return $this;
	}
332567
protected function injectVars($param)
    {
        if (!is_string($param) || !preg_match_all('/\{([^\}\{]+)\}/', $param, $matches)) {
            return $this->getCorrectType($param);
        }

        foreach ($matches[1] as $index => $match) {
            $key = $this->prepareVarName($match);

            if (!isset($this->vars[$key])) {
                continue;
            }

            $param = str_replace(sprintf('{%s}', $match), $this->vars[$key], $param);
        }

        return $this->getCorrectType($param);
    }
937023
public function addParameters(array $params)
    {
        if (!is_array($params)) {
            throw new \InvalidArgumentException('$params has to be an array');
        }
        $this->parameters = array_merge($this->parameters, $params);
    }
1332911
protected function ifAlreadyRegistered(Parameter $param)
    {
        if ($this->registered($param->attributeName())) {
            throw new InvalidParameterException(\sprintf(
                'The parameter "%s" is already registered',
                $param instanceof Option ? $param->long() : $param->name()
            ));
        }
    }
1277046
public function registerParameters($parameters)
	{
		foreach ($parameters as $parameter => $value) {
			if (property_exists($this, $parameter)) {
				$this->$parameter = $value;
			}
		}
	}
1242957
public function setParams($params): void
    {
        if (!\is_array($params) && !\is_object($params)) {
            throw new EventException(
                'Event parameters must be an array or object; received `' . \gettype($params) . '`'
            );
        }

        $this->params = $params;
    }
1102295
protected function checkParameters()
    {
        if (isset($this->parameters[self::PARAMETER_DEFAULT_LANGUAGE])) {
            self::$DEFAULT_LANGUAGE = $this->parameters[self::PARAMETER_DEFAULT_LANGUAGE];
            unset($this->parameters[self::PARAMETER_DEFAULT_LANGUAGE]);
        }
        if (isset($this->parameters[self::PARAMETER_ACCEPTED_LANGUAGES])) {
            $this->acceptedLanguages = explode(',', $this->parameters[self::PARAMETER_ACCEPTED_LANGUAGES]);
            unset($this->parameters[self::PARAMETER_ACCEPTED_LANGUAGES]);
        }
        if (isset($this->parameters[self::PARAMETER_LANGUAGE_PARAMETER_NAME])) {
            $this->languageParameterName = $this->parameters[self::PARAMETER_LANGUAGE_PARAMETER_NAME];
            unset($this->parameters[self::PARAMETER_LANGUAGE_PARAMETER_NAME]);
        }
        if (isset($this->parameters[self::PARAMETER_FORCE_REDIRECT])) {
            $this->forceRedirect = (bool)$this->parameters[self::PARAMETER_FORCE_REDIRECT];
            unset($this->parameters[self::PARAMETER_FORCE_REDIRECT]);
        }
    }
730000
protected function checkParams( \stdClass $params, array $names )
	{
		foreach( $names as $name )
		{
			if( !property_exists( $params, $name ) ) {
				throw new \Aimeos\Controller\ExtJS\Exception( sprintf( 'Missing parameter "%1$s"', $name ), -1 );
			}
		}
	}
26345
private function validateApiParameters($keys = null, $params = null)
    {
        // Assert API has defined an id/endpoint
        $this->assertApiId();

        // Assert API keys array structure is valid
        $this->assertKeysArrayValid($keys);

        // Assert keys array has minimum required optional parameters
        $this->assertKeysHasMinOptParams($keys, $params);

        // Assert and set authentication parameters from Auth object
        $params = $this->setAuthenticationParameters($keys, $params, 'req');
        $params = $this->setAuthenticationParameters($keys, $params, 'opt');

        // Assert required argument parameters exist (non-authentication)
        $this->assertReqParameters($keys, $params);

        // Remove extra parameters not defined in keys array
        $this->removeUnknownParameters($keys, $params);

        return $params;
    }
1007470
public function handle(...$params): void
    {
        /* @var Server $server */
        $server = array_shift($params);
        /* @var int $fd */
        $fd = array_shift($params);
        /* @var Container $app */
        $app = $server->getApplication();

        $packData = $app->make('websocket.parser')->pack(
            $app->make('websocket.data_converter')->conversion($params)
        );

        if ($server->getServer()->isEstablished($fd)) {
            $server->getServer()->push($fd, $packData);

            return;
        }

        throw new OutOfBoundsException("The fd:[{$fd}] not websocket or websocket close");
    }
523259
public function isApplicable(array $params)
    {
        $this->setOutputColorVisibility($params);

        return $this->hasParameter($params, '-vvv') || $this->hasParameter($params, '--verbose', 3);
    }
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);
      }
    });
  }