Java tutorial
/** * Copyright 2011 Link Intersystems GmbH <rene.link@link-intersystems.com> * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.link_intersystems.lang; import java.util.Arrays; import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.lang3.StringUtils; /** * Assertion logic that is mostly used to validate methods pre- and * post-conditions. Encapsulates assertion logic. * * @author Ren Link <a * href="mailto:rene.link@link-intersystems.com">[rene.link@link- * intersystems.com]</a> * @since 1.2.0.0 */ public abstract class Assert { /** * Assert that a non-null value is returned by either returning the * <code>value</code> that is checked to be not <code>null</code> or the * <code>defaultIfNull</code> value. * * @param value * @param defaultIfNull * @return * @since 1.2.0.0 */ public static <T> T defaultIfNull(T value, T defaultIfNull) { notNull("defaultIfNull", defaultIfNull); T guaranteedNotNull = ObjectUtils.defaultIfNull(value, defaultIfNull); return guaranteedNotNull; } /** * Assert that a named value is not <code>null</code> or throw an * {@link IllegalArgumentException}. * * @param name * the name of the value that must of the Assert. * @param value * the value of the Assert. * @since 1.2.0.0 */ public static void notNull(String name, Object value) throws IllegalArgumentException { if (value == null) { throw new IllegalArgumentException(name + " must not be null"); } } /** * Assert that a named string value is not blank. A string is considered * blank if is is * <ul> * <li>null</li> * <li>""</li> * <li>" " contains only whitespaces</li> * </ul> * * @param name * a descriptive name of the string value. * @param value * the string value. */ public static void notBlank(String name, String value) throws IllegalArgumentException { if (StringUtils.isBlank(value)) { throw new IllegalArgumentException(name + " must not be blank"); } } /** * Assert that a value is greater than a limit. * * @param greaterThan * the greater limit. * @param name * a descriptive name of the value. * @param value * the value. * * @since 1.2.0.0 */ public static void greater(String name, int greaterThan, int value) { if (not(value > greaterThan)) { String formatted = String.format("%s must be greater than %s", name, Integer.toString(greaterThan)); throw new IllegalArgumentException(formatted); } } /* * Increase the readability of conditional statements. */ private static boolean not(boolean condition) { return !condition; } /** * Assert that a value is greater than or equal to a limit. * * @param greaterOrEqual * the limit. * @param name * a descriptive name of the value. * @param value * the value. * * @since 1.2.0.0 */ public static void greaterOrEqual(String name, int greaterOrEqual, int value) { if (not(value >= greaterOrEqual)) { String formatted = String.format("%s must be greater than or equal to %s", name, Integer.toString(greaterOrEqual)); throw new IllegalArgumentException(formatted); } } /** * Assert that a double is greater than or equal to a limit. * * @param greaterOrEqual * the limit. * @param name * a descriptive name of the value. * @param value * the value. * * @since 1.2.0.0 */ public static void greaterOrEqual(String name, double greaterOrEqual, double value) { if (not(value >= greaterOrEqual)) { String formatted = String.format("%s must be greater than or equal to %s", name, Double.toString(greaterOrEqual)); throw new IllegalArgumentException(formatted); } } /** * Assert that a value is lower than a limit. * * @param lowerThan * the lower limit. * @param name * a descriptive name of the value. * @param value * the value. * * @since 1.2.0.0 */ public static void lower(String name, int lowerThan, int value) { if (not(value < lowerThan)) { String formatted = String.format("%s must be lower than %s", name, Integer.toString(lowerThan)); throw new IllegalArgumentException(formatted); } } /** * Assert that a value is lower than or equal to a limit. * * @param lowerOrEqual * the limit. * @param name * a descriptive name of the value. * @param value * the value. * * @since 1.2.0.0 */ public static void lowerOrEqual(String name, int lowerOrEqual, int value) { if (not(value <= lowerOrEqual)) { String formatted = String.format("%s must be lower than or equal to %s", name, Integer.toString(lowerOrEqual)); throw new IllegalArgumentException(formatted); } } /** * Assert that a value mets a condition or throw an * {@link IllegalArgumentException}. * * @param expectedTruth * the truth that is expected. * @param messageFormat * the message of the {@link IllegalArgumentException}. The * message can be a formatted message as defined by * {@link String#format(String, Object...)}. * @param messageFormatArgs * the arguments that should be applied to the formatted message. * @throws IllegalArgumentException * if the condition is not met. * @since 1.2.0.0 */ public static void isTrue(boolean expectedTruth, String messageFormat, Object... messageFormatArgs) throws IllegalArgumentException { if (not(expectedTruth)) { String formatted = String.format(messageFormat, messageFormatArgs); throw new IllegalArgumentException(formatted); } } /** * Assert that a value is an instance of one of expected classes or throw an * {@link IllegalArgumentException}. * * @param name * the name of the value. * @param value * the value. * @param expectedInstanceOfs * the expected classes that the value must be an instance of. * @since 1.2.0.0 */ public static void instanceOf(String name, Object value, Class<?>... expectedInstanceOfs) { for (int i = 0; i < expectedInstanceOfs.length; i++) { Class<?> expectedInstanceOf = expectedInstanceOfs[i]; if (expectedInstanceOf.isInstance(value)) { return; } } String exceptionMessage = String.format("%s must be an instance of %s", name, Arrays.toString(expectedInstanceOfs)); throw new IllegalArgumentException(exceptionMessage); } /** * Assert that a value is the same class as the expected class or throws an * {@link IllegalArgumentException}. * * @param name * the name of the value. * @param expectedClass * the expected class. * @param value * the value. * @since 1.2.0.0 */ public static void sameClass(String name, Class<?> expectedClass, Class<?> value) { if (expectedClass != value) { String exceptionMessage = String.format("%s must be %s, but was %s", name, expectedClass, value); throw new IllegalArgumentException(exceptionMessage); } } /** * Assert that the value <code>int</code> is not equal to the notExpected * <code>int</code>. * * @param name * the name of the value. * @param notExcepted * the <code>int</code> value that the value should not be equal * to. * @param value * the <code>int</code> value to ensure to be not equal to the * notExpected <code>int</code>. * @since 1.2.0.0 */ public static void notEqual(String name, int notExcepted, int value) { if (notExcepted == value) { String exceptionMessage = String.format("%s was %s, but must not be equal to %s", name, value, notExcepted); throw new IllegalArgumentException(exceptionMessage); } } /** * Assert that the value <code>int</code> is equal to the expected * <code>int</code>. * * @param name * the name of the value. * @param expected * the <code>int</code> value that the value should be equal to. * @param value * the <code>int</code> value to ensure to be equal to the * expected <code>int</code>. * @since 1.2.0.0 */ public static void equal(String name, int expected, int value) { if (expected != value) { String exceptionMessage = String.format("%s was %s, but must be %s", name, value, expected); throw new IllegalArgumentException(exceptionMessage); } } /** * Assert that the value {@link Object} is equal to the expected * {@link Object} according to the {@link Object#equals(Object)} * specification. * * @param name * the name of the value. * @param expected * the {@link Object} value that the value should be equal to. * @param value * the {@link Object} value to ensure to be equal to the expected * {@link Object}. * @since 1.2.0.0 */ public static void equal(String name, Object expected, Object value) { if (expected == null && value == null) { return; } Object compare = expected; Object other = value; if (expected == null) { compare = value; other = expected; } if (!compare.equals(other)) { String exceptionMessage = String.format("%s was %s, but must be %s", name, value, expected); throw new IllegalArgumentException(exceptionMessage); } } }