{@inheritDoc}

@throws IllegalArgumentException {@inheritDoc}
499813
@Override
  public void validateUpdate(final ResourcePool newPool) {
    super.validateUpdate(newPool);

    SizedResourcePool sizedPool = (SizedResourcePool)newPool;
    // Ensure unit type has not changed
    if (!this.getUnit().getClass().equals(sizedPool.getUnit().getClass())) {
      throw new IllegalArgumentException("ResourcePool for " + sizedPool.getType() + " with ResourceUnit '"
          + sizedPool.getUnit() + "' can not replace '" + this.getUnit() + "'");
    }

    // Ensure replacement has positive space
    if (sizedPool.getSize() <= 0) {
      throw new IllegalArgumentException("ResourcePool for " + sizedPool.getType()
          + " must specify space greater than 0");
    }
  }
629274
public function noMoreDefinedArguments()
    {
        $definedArguments = array_filter($this->arguments, function ($argument) {
            return !is_null($argument);
        });

        if ($count = count($definedArguments)) {
            throw new InvalidArgumentException('You pass '.$count.' unexpected not null arguments');
        }
    }
268889
public static void notNullOrEmpty(String parameter, String name) throws IllegalArgumentException {
		if (parameter == null || parameter.isEmpty()) {
			throw new IllegalArgumentException(name + " is null or empty.");
		}
	}
1030607
public static final void validateKey(String key) throws IllegalArgumentException {
        if (StringUtils.isEmpty(key) || "..".equals(key) || ".".equals(key) || !KEY_PATTERN.matcher(key).matches()) {
            LOG.error("'{}' does not appear to be valid {}", key, KEY_PATTERN);
            throw new IllegalArgumentException(key+" does not appear to be a valid blob key");
        }
    }
244636
public static void notNull(@Nullable Object value, String name) {
        if (value == null) {
            throw new IllegalArgumentException(name + " must not be null!");
        }
    }
49856
private void assertFieldValue(Field field, Object fieldValue) {
    if (fieldValue == null && isFieldRequired(field)) {
      throw new IllegalArgumentException("Non-nullable field " + field.getName()
          + ". This field is either annotated as REQUIRED or is a primitive type.");
    }
  }
446002
public void add(Key k, Value v) throws IllegalArgumentException {
    add(k, v.get());
  }
1303804
protected void verifyParameterLegality(Parameter... parameters) {
    for (Parameter parameter : parameters)
      if (illegalParamNames.contains(parameter.name)) {
        throw new IllegalArgumentException(
                "Parameter '" + parameter.name + "' is reserved for RestFB use - you cannot specify it yourself.");
      }
  }
231840
public static void EQ(long parameter, long expected, String name) throws IllegalArgumentException {
		if (parameter != expected) {
			throw new IllegalArgumentException(String.format("%s is not %d.", name, expected));
		}
	}
635668
public static void assertIdentifier( String id) throws IllegalArgumentException
    {
    if( !isIdentifier( id))
      {
      throw
        new IllegalArgumentException
        ( (id==null? "null" : ("\"" + String.valueOf( id) + "\""))
          + " is not a valid identifier");
      }
    }
585241
@Override
    public void error(String code, Object... arguments)
        throws NullPointerException, IllegalArgumentException {

        this.store.add(Level.ERROR, resolveMessage(code, arguments));
    }
1197499
public void setLevels(Level minLevel, Level maxLevel) throws IllegalArgumentException {
        if (minLevel != null && maxLevel != null && minLevel.intValue() > maxLevel.intValue()) {
            throw new IllegalArgumentException("Value of the minLevel parameter should specify level not larger than the value of the maxLevel parametere.");
        }
        this.minLevel = minLevel;
        this.maxLevel = maxLevel;
    }
1269132
@ArgumentsChecked
	@Throws(IllegalNullArgumentException.class)
	private static String format(@Nonnull final Class<? extends Annotation> annotation) {
		if (annotation == null) {
			throw new IllegalNullArgumentException("annotation");
		}
		return String.format(MESSAGE_WITH_ANNOTATION, annotation.getName());
	}
446420
public void skip(long n) throws IllegalArgumentException, NoSuchElementException
   {
      if (n < 0)
      {
         throw new IllegalArgumentException("skip(" + n + ")");
      }

      for (long i = 0; i < n; i++)
      {
         next();
      }
   }
678142
public void set(Object object, Object value) throws IllegalAccessException, IllegalArgumentException {
        if (null != setter) {
            try {
                setter.invoke(object, value);
            } catch (InvocationTargetException ite) {
                if (ite.getCause() instanceof RuntimeException && !(ite.getCause() instanceof JTransfoException)) {
                    throw (RuntimeException) ite.getCause();
                }
                throw new JTransfoException(String.format(GET_SET_ITO, setter.getName(), object.getClass().getName(),
                        setter.getDeclaringClass().getName(), ite.getCause().getMessage()), ite.getCause());
            }
        } else {
            if (!setUsingFieldLogged) {
                log.warn("Cannot find setter (not public, wrong name or wrong type), "
                                + "using field to access field {} of {}.", name, field.getType().getName());
                setUsingFieldLogged = true;
            }
            field.set(object, value);
        }
    }
211083
@Override
    public T addAsServiceProviderAndClasses(Class<?> serviceInterface, Class<?>... serviceImpls)
        throws IllegalArgumentException {
        Validate.notNull(serviceInterface, "ServiceInterface must be specified");
        Validate.notNullAndNoNullValues(serviceImpls, "ServiceImpls must be specified and can not contain null values");

        addAsServiceProvider(serviceInterface, serviceImpls);
        addClass(serviceInterface);
        return addClasses(serviceImpls);
    }
681915
synchronized public void addAppender(Appender appender) throws IllegalArgumentException {
        if (appender == null) {
            throw new IllegalArgumentException("Appender not allowed to be null");
        }

        for (Appender p : appenderList) {
            if (p.getClass() == appender.getClass())
                return;
        }
        appenderList.add(appender);
    }