Throws an {@link IllegalArgumentException} if {@link #isMinimumSdkLevel(int)} is {@code false}
on the given level.

@see android.os.Build.VERSION_CODES
962919
public static void checkMinimumSdkLevel(int minimumSdkLevel) {
    Preconditions.checkArgument(
        isMinimumSdkLevel(minimumSdkLevel),
        "running on Android SDK level %s but requires minimum %s",
        Build.VERSION.SDK_INT,
        minimumSdkLevel);
  }
699904
public static boolean isNonnegativeInteger(String s) {
        if (isEmpty(s)) return defaultEmptyOK;

        try {
            int temp = Integer.parseInt(s);

            if (temp >= 0) return true;
            return false;
        } catch (Exception e) {
            return false;
        }

        // return(isSignedInteger(s, secondArg)
        // &&((isEmpty(s) && secondArg)  ||(parseInt(s) >= 0) ) );
    }
436092
protected boolean validateLayout(Dimension dim)
    {
        if (majorAxis == X_AXIS)
        {
            majorRequest = getRequirements(X_AXIS, majorRequest);
            minorRequest = getRequirements(Y_AXIS, minorRequest);
            oldDimension.setSize(majorRequest.preferred, minorRequest.preferred);
        }
        else
        {
            majorRequest = getRequirements(Y_AXIS, majorRequest);
            minorRequest = getRequirements(X_AXIS, minorRequest);
            oldDimension.setSize(minorRequest.preferred, majorRequest.preferred);
        }

        majorReqValid = true;
        minorReqValid = true;
        majorAllocValid = true;
        minorAllocValid = true;
        return false;
    }
1265612
private static boolean isCoveredByMinimumLevel(final String tag, final Level level) {
		return provider.getMinimumLevel(tag).ordinal() <= level.ordinal();
	}
542343
private void validate() {

    if ((this.segments.length < 0) && (!this.snapshot)) {
      throw new IllegalArgumentException("segments.length:" + Integer.valueOf(this.segments.length));
    }
    for (int i = 0; i < this.segments.length; i++) {
      if (this.segments[i] < 0) {
        throw new IllegalArgumentException("segments[" + i + "]:" + Integer.valueOf(this.segments[i]));
      }
    }
    if (this.phaseNumber != null) {
      if (this.phaseNumber.intValue() < 0) {
        throw new IllegalArgumentException("phaseNumber:" + this.phaseNumber);
      }
      if (this.phase == null) {
        throw new IllegalArgumentException("phaseNumber (phase==null):" + this.phaseNumber);
      }
      if ((this.phase == DevelopmentPhase.RELEASE) && (this.phaseNumber.intValue() != 0)) {
        throw new IllegalArgumentException("phaseNumber (phase==RELEASE):" + this.phaseNumber);
      }
    }
  }
532139
public synchronized void checkIfCreateNonPersistentTimerAllowed(EJBModuleMetaDataImpl mmd) {
        if (ivStopping) {
            throw new EJBStoppedException(ivName);
        }

        if (mmd != null && mmd.ivStopping) {
            throw new EJBStoppedException(mmd.getJ2EEName().toString());
        }
    }
425755
@Override public CheckLevel level(JSError error) {
    return error.sourceName != null && error.sourceName.contains(part)
        ? super.level(error) /** suppress */
        : null /** proceed */;
  }
919979
private void verifyNumber(Number value, Number minimum, Number maximum) {

    if (minimum != null) {
      if (maximum != null) {
        assert ((value.doubleValue() >= minimum.doubleValue()) || (value.doubleValue() <= maximum.doubleValue()));
      } else {
        assert (value.doubleValue() >= minimum.doubleValue());
      }
    } else if (maximum != null) {
      assert (value.doubleValue() <= maximum.doubleValue());
    } else {
      throw new NlsNullPointerException("minimum & maximum");
    }
  }
318181
private Integer findMinimumSafeLevel(PackageIndex<Integer> index) {
        if (index == null) {
            return null;
        }
        Integer minimumLevel = index.find(name);
        if (minimumLevel == null) {
            // Find by groups
            for (String group : groups) {
                minimumLevel = index.find(group);
                if (minimumLevel != null) {
                    break;
                }
            }
        }
        return minimumLevel;
    }
1315181
public static void checkMinimalPollingPeriod(TimeUnit pollUnit, int pollPeriod)
      throws IllegalArgumentException {
    int period = (int) MINIMAL_POLL_UNIT.convert(pollPeriod, pollUnit);
    Preconditions.checkArgument(period >= MINIMAL_POLL_PERIOD,
        "Polling period %d %d is below the minimal polling period", pollPeriod, pollUnit);
  }
1110553
protected void checkInputParameters(final IChemObjectBuilder builder,
                                        final double minMass, final double maxMass,
                                        final MolecularFormulaRange mfRange) {
        if ((minMass < 0.0) || (maxMass < 0.0)) {
            throw (new IllegalArgumentException(
                    "The minimum and maximum mass values must be >=0"));
        }

        if ((minMass > maxMass)) {
            throw (new IllegalArgumentException(
                    "Minimum mass must be <= maximum mass"));
        }

        if ((mfRange == null) || (mfRange.getIsotopeCount() == 0)) {
            throw (new IllegalArgumentException(
                    "The MolecularFormulaRange parameter must be non-null and must contain at least one isotope"));
        }

        // Sort the elements by mass in ascending order. That speeds up
        // the search.
        for (IIsotope isotope : mfRange.isotopes()) {
            // Check if exact mass of each isotope is set
            if (isotope.getExactMass() == null)
                throw new IllegalArgumentException(
                        "The exact mass value of isotope " + isotope
                                + " is not set");
        }
    }
1366230
protected void checkScales() {
		if( getScale(0) < 0 ) {
			throw new IllegalArgumentException("The first layer must be more than zero.");
		}

		double prevScale = 0;
		for( int i = 0; i < getNumLayers(); i++ ) {
			double s = getScale(i);
			if( s < prevScale )
				throw new IllegalArgumentException("Higher layers must be the same size or larger than previous layers.");
			prevScale = s;
		}
	}
445897
@SuppressWarnings({"unchecked", "rawtypes"})
    public static <T extends Comparable> void notMin(final T arg, final T min, final String name) {
        
        if(arg == null) {
            throw new IllegalArgumentException(String.format("%s should not be null.", name));
        }
        
        if(arg.compareTo(min) < 0) {
            throw new IllegalArgumentException(String.format("%s cannot be smaller than %s", name, min.toString()));
        }
        
    }
570133
public static void notNullOrEmpty(final String string, final String message) throws IllegalArgumentException {
        if (string == null || string.length() == 0) {
            throw new IllegalArgumentException(message);
        }
    }
388328
public static void validateBetween(Number value, Number min, Number max, String errorMsg) throws ValidateException {
		if (false == isBetween(value, min, max)) {
			throw new ValidateException(errorMsg);
		}
	}
247723
private void validateTypeNotIn(TypeMirror t, Set<TypeKind> invalidKinds) {
        if (invalidKinds.contains(t.getKind()))
            throw new IllegalArgumentException(t.toString());
    }
702806
public void setM(double m)
    {
        if(m < 0 || Double.isInfinite(m) || Double.isNaN(m))
            throw new ArithmeticException("The minimum count must be a non negative number");
        this.m = m;
    }