Java tutorial
/** * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.collect; import java.util.Collection; import java.util.Map; import java.util.Map.Entry; import java.util.regex.Pattern; import com.google.common.math.DoubleMath; /** * Contains utility methods for checking inputs to methods. * <p> * This utility is used throughout the system to validate inputs to methods. * Most of the methods return their validated input, allowing patterns like this: * <pre> * // constructor * public Person(String name, int age) { * this.name = ArgChecker.notBlank(name, "name"); * this.age = ArgChecker.notNegative(age, "age"); * } * </pre> */ public final class ArgChecker { /** * Restricted constructor. */ private ArgChecker() { } //------------------------------------------------------------------------- /** * Checks that the specified boolean is true. * <p> * Given the input parameter, this returns normally only if it is true. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isTrue(collection.contains("value"), "Collection must contain 'value'"); * </pre> * * @param validIfTrue a boolean resulting from testing an argument * @param message the error message, not null * @throws IllegalArgumentException if the test value is false */ public static void isTrue(boolean validIfTrue, String message) { // return void, not the parameter, as no need to check a boolean method parameter if (!validIfTrue) { throw new IllegalArgumentException(message); } } /** * Checks that the specified boolean is true. * <p> * Given the input parameter, this returns normally only if it is true. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isTrue(collection.contains("value"), "Collection must contain 'value': {}", collection); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean parameter value. * <p> * The message is produced using a template that contains zero to many "{}" placeholders. * Each placeholder is replaced by the next available argument. * If there are too few arguments, then the message will be left with placeholders. * If there are too many arguments, then the excess arguments are appended to the * end of the message. No attempt is made to format the arguments. * See {@link Messages#format(String, Object...)} for more details. * * @param validIfTrue a boolean resulting from testing an argument * @param message the error message with {} placeholders, not null * @param arg the message arguments * @throws IllegalArgumentException if the test value is false */ public static void isTrue(boolean validIfTrue, String message, Object... arg) { // return void, not the parameter, as no need to check a boolean method parameter if (!validIfTrue) { throw new IllegalArgumentException(Messages.format(message, arg)); } } /** * Checks that the specified boolean is false. * <p> * Given the input parameter, this returns normally only if it is false. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isFalse(collection.contains("value"), "Collection must not contain 'value'"); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean parameter value. * * @param validIfFalse a boolean resulting from testing an argument * @param message the error message, not null * @throws IllegalArgumentException if the test value is true */ public static void isFalse(boolean validIfFalse, String message) { // return void, not the parameter, as no need to check a boolean method parameter if (validIfFalse) { throw new IllegalArgumentException(message); } } /** * Checks that the specified boolean is false. * <p> * Given the input parameter, this returns normally only if it is false. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isFalse(collection.contains("value"), "Collection must not contain 'value': {}", collection); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean parameter value. * <p> * The message is produced using a template that contains zero to many "{}" placeholders. * Each placeholder is replaced by the next available argument. * If there are too few arguments, then the message will be left with placeholders. * If there are too many arguments, then the excess arguments are appended to the * end of the message. No attempt is made to format the arguments. * See {@link Messages#format(String, Object...)} for more details. * * @param validIfFalse a boolean resulting from testing an argument * @param message the error message with {} placeholders, not null * @param arg the message arguments, not null * @throws IllegalArgumentException if the test value is true */ public static void isFalse(boolean validIfFalse, String message, Object... arg) { // return void, not the parameter, as no need to check a boolean method parameter if (validIfFalse) { throw new IllegalArgumentException(Messages.format(message, arg)); } } //------------------------------------------------------------------------- /** * Checks that the specified parameter is non-null. * <p> * Given the input parameter, this returns only if it is non-null. * For example, in a constructor: * <pre> * this.name = ArgChecker.notNull(name, "name"); * </pre> * * @param <T> the type of the input parameter reflected in the result * @param parameter the parameter to check, null throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null */ public static <T> T notNull(T parameter, String name) { if (parameter == null) { throw new IllegalArgumentException(notNullMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notNullMsg(String name) { return "Argument '" + name + "' must not be null"; } /** * Checks that the specified item is non-null. * <p> * Given the input parameter, this returns only if it is non-null. * One use for this method is in a stream: * <pre> * ArgChecker.notNull(coll, "coll") * coll.stream() * .map(ArgChecker::notNullItem) * ... * </pre> * * @param <T> the type of the input parameter reflected in the result * @param parameter the parameter to check, null throws an exception * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null */ public static <T> T notNullItem(T parameter) { if (parameter == null) { throw new IllegalArgumentException("Argument array/collection/map must not contain null"); } return parameter; } //------------------------------------------------------------------------- /** * Checks that the specified parameter is non-null and matches the specified pattern. * <p> * Given the input parameter, this returns only if it is non-null and matches * the regular expression pattern specified. * For example, in a constructor: * <pre> * this.name = ArgChecker.matches(REGEX_NAME, name, "name"); * </pre> * * @param pattern the pattern to check against, not null * @param parameter the parameter to check, null throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static String matches(Pattern pattern, String parameter, String name) { notNull(pattern, "pattern"); notNull(parameter, name); if (pattern.matcher(parameter).matches() == false) { throw new IllegalArgumentException(matchesMsg(pattern, name)); } return parameter; } // extracted to aid inlining performance private static String matchesMsg(Pattern pattern, String name) { return "Argument '" + name + "' must match pattern: " + pattern; } //------------------------------------------------------------------------- /** * Checks that the specified parameter is non-null and not blank. * <p> * Given the input parameter, this returns the input only if it is non-null * and contains at least one non whitespace character. * This is often linked with a call to {@code trim()}. * For example, in a constructor: * <pre> * this.name = ArgChecker.notBlank(name, "name").trim(); * </pre> * <p> * The parameter is trimmed using {@link String#trim()} to determine if it is empty. * The result is the original parameter, not the trimmed one. * * @param parameter the parameter to check, null or blank throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or blank */ public static String notBlank(String parameter, String name) { notNull(parameter, name); if (parameter.trim().isEmpty()) { throw new IllegalArgumentException(notBlankMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notBlankMsg(String name) { return "Argument '" + name + "' must not be blank"; } //------------------------------------------------------------------------- /** * Checks that the specified parameter is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains * at least one character, which may be a whitespace character. * See also {@link #notBlank(String, String)}. * For example, in a constructor: * <pre> * this.name = ArgChecker.notEmpty(name, "name"); * </pre> * * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static String notEmpty(String parameter, String name) { notNull(parameter, name); if (parameter.isEmpty()) { throw new IllegalArgumentException(notEmptyMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notEmptyMsg(String name) { return "Argument '" + name + "' must not be empty"; } /** * Checks that the specified parameter array is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains * at least one element. The element is not validated and may be null. * For example, in a constructor: * <pre> * this.names = ArgChecker.notEmpty(names, "names"); * </pre> * * @param <T> the type of the input array reflected in the result * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <T> T[] notEmpty(T[] parameter, String name) { notNull(parameter, name); if (parameter.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notEmptyArrayMsg(String name) { return "Argument array '" + name + "' must not be empty"; } /** * Checks that the specified parameter array is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains * at least one element. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static int[] notEmpty(int[] parameter, String name) { notNull(parameter, name); if (parameter.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return parameter; } /** * Checks that the specified parameter array is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains * at least one element. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static long[] notEmpty(long[] parameter, String name) { notNull(parameter, name); if (parameter.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return parameter; } /** * Checks that the specified parameter array is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains * at least one element. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static double[] notEmpty(double[] parameter, String name) { notNull(parameter, name); if (parameter.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return parameter; } /** * Checks that the specified parameter iterable is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains * at least one element. The element is not validated and may be null. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param <T> the element type of the input iterable reflected in the result * @param <I> the type of the input iterable, reflected in the result * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <T, I extends Iterable<T>> I notEmpty(I parameter, String name) { notNull(parameter, name); if (!parameter.iterator().hasNext()) { throw new IllegalArgumentException(notEmptyIterableMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notEmptyIterableMsg(String name) { return "Argument iterable '" + name + "' must not be empty"; } /** * Checks that the specified parameter collection is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains at least one element. * The element is not validated and may contain nulls if the collection allows nulls. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param <T> the element type of the input collection reflected in the result * @param <C> the type of the input collection, reflected in the result * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <T, C extends Collection<T>> C notEmpty(C parameter, String name) { notNull(parameter, name); if (parameter.isEmpty()) { throw new IllegalArgumentException(notEmptyCollectionMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notEmptyCollectionMsg(String name) { return "Argument collection '" + name + "' must not be empty"; } /** * Checks that the specified parameter map is non-null and not empty. * <p> * Given the input parameter, this returns only if it is non-null and contains at least one mapping. * The element is not validated and may contain nulls if the collection allows nulls. * For example, in a constructor: * <pre> * this.keyValues = ArgChecker.notEmpty(keyValues, "keyValues"); * </pre> * * @param <K> the key type of the input map key, reflected in the result * @param <V> the value type of the input map value, reflected in the result * @param <M> the type of the input map, reflected in the result * @param parameter the parameter to check, null or empty throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <K, V, M extends Map<K, V>> M notEmpty(M parameter, String name) { notNull(parameter, name); if (parameter.isEmpty()) { throw new IllegalArgumentException(notEmptyMapMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notEmptyMapMsg(String name) { return "Argument map '" + name + "' must not be empty"; } //------------------------------------------------------------------------- /** * Checks that the specified parameter array is non-null and contains no nulls. * <p> * Given the input parameter, this returns only if it is non-null and contains no nulls. * For example, in a constructor: * <pre> * this.values = ArgChecker.noNulls(values, "values"); * </pre> * * @param <T> the type of the input array reflected in the result * @param parameter the parameter to check, null or contains null throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or contains nulls */ public static <T> T[] noNulls(T[] parameter, String name) { notNull(parameter, name); for (int i = 0; i < parameter.length; i++) { if (parameter[i] == null) { throw new IllegalArgumentException( "Argument array '" + name + "' must not contain null at index " + i); } } return parameter; } /** * Checks that the specified parameter collection is non-null and contains no nulls. * <p> * Given the input parameter, this returns only if it is non-null and contains no nulls. * For example, in a constructor: * <pre> * this.values = ArgChecker.noNulls(values, "values"); * </pre> * * @param <T> the element type of the input iterable reflected in the result * @param <I> the type of the input iterable, reflected in the result * @param parameter the parameter to check, null or contains null throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or contains nulls */ public static <T, I extends Iterable<T>> I noNulls(I parameter, String name) { notNull(parameter, name); for (Object obj : parameter) { if (obj == null) { throw new IllegalArgumentException("Argument iterable '" + name + "' must not contain null"); } } return parameter; } /** * Checks that the specified parameter map is non-null and contains no nulls. * <p> * Given the input parameter, this returns only if it is non-null and contains no nulls. * For example, in a constructor: * <pre> * this.keyValues = ArgChecker.noNulls(keyValues, "keyValues"); * </pre> * * @param <K> the key type of the input map key, reflected in the result * @param <V> the value type of the input map value, reflected in the result * @param <M> the type of the input map, reflected in the result * @param parameter the parameter to check, null or contains null throws an exception * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter}, not null * @throws IllegalArgumentException if the input is null or contains nulls */ public static <K, V, M extends Map<K, V>> M noNulls(M parameter, String name) { notNull(parameter, name); for (Entry<K, V> entry : parameter.entrySet()) { if (entry.getKey() == null) { throw new IllegalArgumentException("Argument map '" + name + "' must not contain a null key"); } if (entry.getValue() == null) { throw new IllegalArgumentException("Argument map '" + name + "' must not contain a null value"); } } return parameter; } //------------------------------------------------------------------------- /** * Checks that the argument is not negative. * <p> * Given the input parameter, this returns only if it is zero or greater. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegative(amount, "amount"); * </pre> * * @param parameter the parameter to check * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the input is negative */ public static int notNegative(int parameter, String name) { if (parameter < 0) { throw new IllegalArgumentException(notNegativeMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notNegativeMsg(String name) { return "Argument '" + name + "' must not be negative"; } /** * Checks that the argument is not negative. * <p> * Given the input parameter, this returns only if it is zero or greater. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegative(amount, "amount"); * </pre> * * @param parameter the parameter to check * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the input is negative */ public static long notNegative(long parameter, String name) { if (parameter < 0) { throw new IllegalArgumentException(notNegativeMsg(name)); } return parameter; } /** * Checks that the argument is not negative. * <p> * Given the input parameter, this returns only if it is zero or greater. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegative(amount, "amount"); * </pre> * * @param parameter the parameter to check * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the input is negative */ public static double notNegative(double parameter, String name) { if (parameter < 0) { throw new IllegalArgumentException(notNegativeMsg(name)); } return parameter; } //------------------------------------------------------------------------- /** * Checks that the argument is not negative or zero. * <p> * Given the input parameter, this returns only if it is greater than zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, "amount"); * </pre> * * @param parameter the parameter to check * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the input is negative or zero */ public static int notNegativeOrZero(int parameter, String name) { if (parameter <= 0) { throw new IllegalArgumentException(notNegativeOrZeroMsg(name)); } return parameter; } // extracted to aid inlining performance private static String notNegativeOrZeroMsg(String name) { return "Argument '" + name + "' must not be negative or zero"; } /** * Checks that the argument is not negative or zero. * <p> * Given the input parameter, this returns only if it is greater than zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, "amount"); * </pre> * * @param parameter the parameter to check * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the input is negative or zero */ public static long notNegativeOrZero(long parameter, String name) { if (parameter <= 0) { throw new IllegalArgumentException(notNegativeOrZeroMsg(name)); } return parameter; } /** * Checks that the argument is not negative or zero. * <p> * Given the input parameter, this returns only if it is greater than zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, "amount"); * </pre> * * @param parameter the parameter to check * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the input is negative or zero */ public static double notNegativeOrZero(double parameter, String name) { if (parameter <= 0) { throw new IllegalArgumentException(notNegativeOrZeroMsg(name)); } return parameter; } /** * Checks that the argument is greater than zero to within a given accuracy. * <p> * Given the input parameter, this returns only if it is greater than zero * using the {@code eps} accuracy for zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, 0.0001d, "amount"); * </pre> * * @param parameter the value to check * @param tolerance the tolerance to use for zero * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the absolute value of the argument is less than eps */ public static double notNegativeOrZero(double parameter, double tolerance, String name) { if (DoubleMath.fuzzyEquals(parameter, 0, tolerance)) { throw new IllegalArgumentException("Argument '" + name + "' must not be zero"); } if (parameter < 0) { throw new IllegalArgumentException("Argument '" + name + "' must be greater than zero"); } return parameter; } //------------------------------------------------------------------------- /** * Checks that the argument is not equal to zero to within a given accuracy. * <p> * Given the input parameter, this returns only if it is not zero comparing * using the {@code eps} accuracy. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notZero(amount, 0.0001d, "amount"); * </pre> * * @param parameter the value to check * @param tolerance the tolerance to use for zero * @param name the name of the parameter to use in the error message, not null * @return the input {@code parameter} * @throws IllegalArgumentException if the absolute value of the argument is less than eps */ public static double notZero(double parameter, double tolerance, String name) { if (DoubleMath.fuzzyEquals(parameter, 0d, tolerance)) { throw new IllegalArgumentException("Argument '" + name + "' must not be zero"); } return parameter; } //------------------------------------------------------------------------- /** * Checks a collection for null elements. * <p> * Given a collection, this returns true if any element is null. * * @param iterable the collection to test, null throws an exception * @return true if the collection contains a null element * @throws IllegalArgumentException if the collection is null */ public static boolean hasNullElement(Iterable<?> iterable) { notNull(iterable, "iterable"); for (Object o : iterable) { if (o == null) { return true; } } return false; } /** * Checks a collection of doubles for negative elements. * <p> * Given a collection, this returns true if any element is negative. * * @param iterable the collection to test, null or contains null throws an exception * @return true if the collection contains a negative element * @throws IllegalArgumentException if the collection is null or any element is null */ public static boolean hasNegativeElement(Iterable<Double> iterable) { notNull(iterable, "collection"); for (Double d : iterable) { notNull(d, "collection element"); if (d < 0) { return true; } } return false; } //------------------------------------------------------------------------- /** * Checks that a value is within the range low < x < high. * <p> * Given a value, this returns true if it is within the specified range * excluding the boundaries. * * @param low the low value of the range * @param high the high value of the range * @param value the value * @return true if low < x < high */ public static boolean isInRangeExclusive(double low, double high, double value) { return (value > low && value < high); } /** * Checks that a value is within the range low <= x <= high. * <p> * Given a value, this returns true if it is within the specified range * including both boundaries. * * @param low the low value of the range * @param high the high value of the range * @param value the value * @return true if low <= x <= high */ public static boolean isInRangeInclusive(double low, double high, double value) { return (value >= low && value <= high); } /** * Checks that a value is within the range low < x <= high. * <p> * Given a value, this returns true if it is within the specified range * excluding the lower boundary but including the upper boundary. * * @param low the low value of the range * @param high the high value of the range * @param value the value * @return true if low < x <= high */ public static boolean isInRangeExcludingLow(double low, double high, double value) { return (value > low && value <= high); } /** * Checks that a value is within the range low <= x < high. * <p> * Given a value, this returns true if it is within the specified range * excluding the upper boundary but including the lower boundary. * * @param low the low value of the range * @param high the high value of the range * @param value the value * @return true if low <= x < high */ public static boolean isInRangeExcludingHigh(double low, double high, double value) { return (value >= low && value < high); } //------------------------------------------------------------------------- /** * Checks that the two values are in order and not equal. * <p> * Given two comparable instances, this checks that the first is "less than" the second. * Two equal values also throw the exception. * * @param <T> the type * @param obj1 the first object, null throws an exception * @param obj2 the second object, null throws an exception * @param param1 the first parameter name, not null * @param param2 the second parameter name, not null * @throws IllegalArgumentException if either input is null or they are not in order */ public static <T> void inOrderNotEqual(Comparable<? super T> obj1, T obj2, String param1, String param2) { notNull(obj1, param1); notNull(obj2, param2); if (obj1.compareTo(obj2) >= 0) { throw new IllegalArgumentException("Invalid order: Expected '" + param1 + "' < '" + param2 + "', but found: '" + obj1 + "' >= '" + obj2); } } /** * Checks that the two values are in order or equal. * <p> * Given two comparable instances, this checks that the first is "less than" or "equal to" the second. * * @param <T> the type * @param obj1 the first object, null throws an exception * @param obj2 the second object, null throws an exception * @param param1 the first parameter name, not null * @param param2 the second parameter name, not null * @throws IllegalArgumentException if either input is null or they are not in order */ public static <T> void inOrderOrEqual(Comparable<? super T> obj1, T obj2, String param1, String param2) { notNull(obj1, param1); notNull(obj2, param2); if (obj1.compareTo(obj2) > 0) { throw new IllegalArgumentException("Invalid order: Expected '" + param1 + "' <= '" + param2 + "', but found: '" + obj1 + "' > '" + obj2); } } }