com.link_intersystems.lang.Assert.java Source code

Java tutorial

Introduction

Here is the source code for com.link_intersystems.lang.Assert.java

Source

/**
 * 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);
        }

    }

}