/*
(non-Javadoc)

@see edu.umd.cs.findbugs.anttask.AbstractFindBugsTask#checkParameters()
175142
@Override
    protected void checkParameters() {
        super.checkParameters();

        if (inputFile == null) {
            throw new BuildException("inputFile element is required");
        }

        checkBoolean(formatDates, "formatDates");
        checkBoolean(noTabs, "noTabs");
        checkBoolean(summary, "summary");
    }
1009104
public void setParameters(java.util.Collection<PolicyParameter> parameters) {
        if (parameters == null) {
            this.parameters = null;
            return;
        }

        this.parameters = new java.util.ArrayList<PolicyParameter>(parameters);
    }
440152
private boolean hasTimeoutCallbackParameters(MethodMap.MethodInfo methodInfo) {
        int numParams = methodInfo.getNumParameters();
        return numParams == 0 ||
               (numParams == 1 && methodInfo.getParameterType(0) == Timer.class);
    }
794020
private static void checkPreconditions(final Set<Object> possibleValues) {
		if( possibleValues == null ) {
			throw new NullPointerException("possibleValues Set should not be null");
		} else if( possibleValues.isEmpty() ) {
			throw new IllegalArgumentException("possibleValues Set should not be empty");
		}
	}
1125836
def check_required_params(self):
        
        for param in self.REQUIRED_FIELDS:
            if param not in self.params:
                raise ValidationError("Missing parameter: {} for {}".format(
                    param, self.__class__.path
                ))

        for child in self.TASKS:
            for param in child.REQUIRED_FIELDS:
                if param not in self.params:
                    raise ValidationError(
                        "Missing parameter: {} for {}".format(param, child.path)
                    )
1001787
private void checkParams(int maxActiveMessages,
                             long messageLockExpiry,
                             int maxBatchSize)

                    throws SIIncorrectCallException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "checkParams",
                        new Object[] {
                                      Integer.valueOf(maxActiveMessages),
                                      Long.valueOf(messageLockExpiry),
                                      Integer.valueOf(maxBatchSize) });

        if (maxActiveMessages < 0)
        {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "checkParams", "SIIncorrectCallException maxActiveMessages < 0");
            throw new SIIncorrectCallException(
                            nls_cwsir.getFormattedMessage(
                                                          "REG_ASYNCH_CONSUMER_ERROR_CWSIR0141",
                                                          new Object[] { Integer.valueOf(maxActiveMessages) },
                                                          null));
        }

        if (messageLockExpiry < 0)
        {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "checkParams", "SIIncorrectCallException messageLockExpiry < 0");
            throw new SIIncorrectCallException(
                            nls_cwsir.getFormattedMessage(
                                                          "REG_ASYNCH_CONSUMER_ERROR_CWSIR0142",
                                                          new Object[] { Long.valueOf(messageLockExpiry) },
                                                          null));
        }

        if (maxBatchSize <= 0)
        {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "checkParams", "SIIncorrectCallException maxBatchSize <= 0");

            throw new SIIncorrectCallException(
                            nls_cwsir.getFormattedMessage(
                                                          "REG_ASYNCH_CONSUMER_ERROR_CWSIR0143",
                                                          new Object[] { Integer.valueOf(maxBatchSize) },
                                                          null));
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "checkParams");
    }
200563
protected function checkParameters()
    {
        $this->checkDocumentTypeParameter();
        $this->checkResponseFolderParameter();
        $this->checkSubTemplateParameter();
        $this->checkFormParameterNameParameter();
        $this->checkThankYouMessageParameter();
        $this->checkSubmitOncePerSessionParameter();
    }
284294
private void checkParams()
   {
      if (backupDir == null)
      {
         throw new IllegalStateException(BACKUP_DIR + " not specified");
      }

      logsDirectory = new File(backupDir);
      if (!PrivilegedFileHelper.exists(logsDirectory))
      {
         if (!PrivilegedFileHelper.mkdirs(logsDirectory))
         {
            throw new IllegalStateException("Could not create the backup directory at "
               + logsDirectory.getAbsolutePath());
         }
      }

      if (defIncrPeriod == null)
      {
         throw new IllegalStateException(DEFAULT_INCREMENTAL_JOB_PERIOD + " not specified");
      }

      defaultIncrementalJobPeriod = Integer.valueOf(defIncrPeriod);

      if (fullBackupType == null)
      {
         throw new IllegalStateException(FULL_BACKUP_TYPE + " not specified");
      }

      if (incrementalBackupType == null)
      {
         throw new IllegalStateException(INCREMENTAL_BACKUP_TYPE + " not specified");
      }
   }
1236258
private void performChecks(Contextual<?> contextual) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "performChecks", this);

        if (!isActive()) {
            throw new ContextNotActiveException();
        }

        if (contextual == null) {
            throw new IllegalArgumentException("Contextual parameter should not be null");
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "performChecks");
    }
1297977
private void ensureParams() {
        if (this.isDirty) {
            // note, it would only be dirty if we actually have inserted a value
            // so therefore no need to check that the parammap is null
            final Buffer restOfParams = this.params;
            this.params = allcoateNewParamBuffer();
            for (final Map.Entry<Buffer, Buffer> entry : this.paramMap.entrySet()) {
                this.params.write(SipParser.SEMI);
                final Buffer key = entry.getKey();
                final Buffer value = entry.getValue();
                key.getBytes(0, this.params);
                if (value != null && !value.isEmpty()) {
                    this.params.write(SipParser.EQ);
                    value.getBytes(0, this.params);
                }
            }
            this.paramMap.clear();
            restOfParams.getBytes(this.params);
            this.originalParams = this.params.slice();
            this.isDirty = false;
        }
    }
1088275
protected void checkNonGenericParameter(Method executeMethod, Parameter parameter) {
        if (isNonGenericCheckTargetType(parameter.getType())) { // e.g. List
            final Type paramedType = parameter.getParameterizedType();
            if (paramedType == null) { // no way? no check just in case
                return;
            }
            if (paramedType instanceof ParameterizedType) {
                final Type[] typeArgs = ((ParameterizedType) paramedType).getActualTypeArguments();
                if (typeArgs != null && typeArgs.length > 0 && "?".equals(typeArgs[0].getTypeName())) { // e.g. List<?>
                    throwActionFormWildcardOnlyListParameterException(executeMethod, parameter);
                }
            } else {
                throwActionFormNonGenericListParameterException(executeMethod, parameter);
            }
        }
    }
1023760
public void setParamsToRuntimeCheck(Predicate<String> paramNames) {
    checkState(this.paramsToRuntimeTypeCheck == null);
    this.paramsToRuntimeTypeCheck = checkNotNull(paramNames);
  }
900698
public static void validateParams(Object... params) throws JinxException {
        for (Object o : params) {
            if (o == null) {
                throw new JinxException("Parameters cannot be null.");
            } else if (o instanceof List) {
                for (Object listObject : (List) o) {
                    if (listObject == null) {
                        throw new JinxException("Objects in list cannot be null.");
                    }
                }
            } else if (o instanceof String) {
                if (((String) o).trim().length() == 0) {
                    throw new JinxException("String cannot be empty.");
                }
            }
        }
    }
70099
def _check_unused_parameters(self):
        """"""
        all_params = set(self.parameters.keys())
        processed_params = set(self._processed_parameters)
        unused_params = all_params - processed_params - RESERVED_ARGS

        if unused_params:
            self.log.warning(
                "The following parameters were ignored: {}".format(
                    ', '.join(sorted(unused_params))
                )
            )
1020017
private void checkDefaults() {
        Utils.require(m_continueAt == null || m_continueAfter == null, "Both continue-at and continue-after parameters cannot be set");
        //Utils.require((m_continueAt == null && m_continueAfter == null) || m_sortOrder == null, "continuation parameters cannot be set if sort order is set");
        if (m_pageSize == -1) m_pageSize = ServerParams.instance().getModuleParamInt("DoradusServer", "search_default_page_size", 100);
    }
1372924
public static void validateBindParametersTypes(Parameters parameters) {
		final Iterator<Parameter> it = parameters.iterator();

		while (it.hasNext()) {
			final Parameter param = it.next();
			final Class<?> paramType = param.getType();

			if (!(param.isSpecialParameter() || SupportedCoreTypes
					.isSupported(paramType))) {
				throw (new IllegalArgumentException("Type " + paramType
						+ " not supported as an annotated query parameter!"));
			}
		}
	}
1054111
private void checkTasks() {
    if (currentTask == null) {
      Handler<Task> task = queue.poll();
      if (task != null) {
        currentTask = new Task(this);
        task.handle(currentTask);
      }
    }
  }