Quellcode-Bibliothek

^© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: Asserts.java Sprache: JAVA

/*
* Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

package jdk.test.lib;

import java.util.Objects;

/**
* Asserts that can be used for verifying assumptions in tests.
*
* An assertion will throw a {@link RuntimeException} if the assertion isn't true.
* All the asserts can be imported into a test by using a static import:
*
* <pre>
* {@code
* import static jdk.test.lib.Asserts.*;
* }
*
* Always provide a message describing the assumption if the line number of the
* failing assertion isn't enough to understand why the assumption failed. For
* example, if the assertion is in a loop or in a method that is called
* multiple times, then the line number won't provide enough context to
* understand the failure.
* </pre>
*/
public class Asserts {

 /**
 * Shorthand for {@link #assertLessThan(Comparable, Comparable)}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertLessThan(Comparable, Comparable)
 */
 public static <T extends Comparable<T>> void assertLT(T lhs, T rhs) {
 assertLessThan(lhs, rhs);
 }

 /**
 * Shorthand for {@link #assertLessThan(Comparable, Comparable, String)}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @see #assertLessThan(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertLT(T lhs, T rhs, String msg) {
 assertLessThan(lhs, rhs, msg);
 }

 /**
 * Calls {@link #assertLessThan(Comparable, Comparable, String)} with a default message.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertLessThan(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertLessThan(T lhs, T rhs) {
 assertLessThan(lhs, rhs, null);
 }

 /**
 * Asserts that {@code lhs} is less than {@code rhs}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static <T extends Comparable<T>>void assertLessThan(T lhs, T rhs, String msg) {
 if (!(compare(lhs, rhs, msg) < 0)) {
 msg = Objects.toString(msg, "assertLessThan")
 + ": expected that " + Objects.toString(lhs)
 + " < " + Objects.toString(rhs);
 fail(msg);
 }
 }

 /**
 * Shorthand for {@link #assertLessThanOrEqual(Comparable, Comparable)}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertLessThanOrEqual(Comparable, Comparable)
 */
 public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs) {
 assertLessThanOrEqual(lhs, rhs);
 }

 /**
 * Shorthand for {@link #assertLessThanOrEqual(Comparable, Comparable, String)}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @see #assertLessThanOrEqual(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs, String msg) {
 assertLessThanOrEqual(lhs, rhs, msg);
 }

 /**
 * Calls {@link #assertLessThanOrEqual(Comparable, Comparable, String)} with a default message.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertLessThanOrEqual(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs) {
 assertLessThanOrEqual(lhs, rhs, null);
 }

 /**
 * Asserts that {@code lhs} is less than or equal to {@code rhs}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs, String msg) {
 if (!(compare(lhs, rhs, msg) <= 0)) {
 msg = Objects.toString(msg, "assertLessThanOrEqual")
 + ": expected that " + Objects.toString(lhs)
 + " <= " + Objects.toString(rhs);
 fail(msg);
 }
 }

 /**
 * Shorthand for {@link #assertEquals(Object, Object)}.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertEquals(Object, Object)
 */
 public static void assertEQ(Object lhs, Object rhs) {
 assertEquals(lhs, rhs);
 }

 /**
 * Shorthand for {@link #assertEquals(Object, Object, String)}.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @see #assertEquals(Object, Object, String)
 */
 public static void assertEQ(Object lhs, Object rhs, String msg) {
 assertEquals(lhs, rhs, msg);
 }

 /**
 * Calls {@link #assertEquals(java.lang.Object, java.lang.Object, java.lang.String)} with a default message.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertEquals(Object, Object, String)
 */
 public static void assertEquals(Object lhs, Object rhs) {
 assertEquals(lhs, rhs, null);
 }

 /**
 * Asserts that {@code lhs} is equal to {@code rhs}.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static void assertEquals(Object lhs, Object rhs, String msg) {
 if ((lhs != rhs) && ((lhs == null) || !(lhs.equals(rhs)))) {
 msg = Objects.toString(msg, "assertEquals")
 + ": expected " + Objects.toString(lhs)
 + " to equal " + Objects.toString(rhs);
 fail(msg);
 }
 }

 /**
 * Calls {@link #assertSame(java.lang.Object, java.lang.Object, java.lang.String)} with a default message.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertSame(Object, Object, String)
 */
 public static void assertSame(Object lhs, Object rhs) {
 assertSame(lhs, rhs, null);
 }

 /**
 * Asserts that {@code lhs} is the same as {@code rhs}.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static void assertSame(Object lhs, Object rhs, String msg) {
 if (lhs != rhs) {
 msg = Objects.toString(msg, "assertSame")
 + ": expected " + Objects.toString(lhs)
 + " to equal " + Objects.toString(rhs);
 fail(msg);
 }
 }

 /**
 * Shorthand for {@link #assertGreaterThanOrEqual(Comparable, Comparable)}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertGreaterThanOrEqual(Comparable, Comparable)
 */
 public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs) {
 assertGreaterThanOrEqual(lhs, rhs);
 }

 /**
 * Shorthand for {@link #assertGreaterThanOrEqual(Comparable, Comparable, String)}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @see #assertGreaterThanOrEqual(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs, String msg) {
 assertGreaterThanOrEqual(lhs, rhs, msg);
 }

 /**
 * Calls {@link #assertGreaterThanOrEqual(Comparable, Comparable, String)} with a default message.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertGreaterThanOrEqual(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs) {
 assertGreaterThanOrEqual(lhs, rhs, null);
 }

 /**
 * Asserts that {@code lhs} is greater than or equal to {@code rhs}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs, String msg) {
 if (!(compare(lhs, rhs, msg) >= 0)) {
 msg = Objects.toString(msg, "assertGreaterThanOrEqual")
 + ": expected " + Objects.toString(lhs)
 + " >= " + Objects.toString(rhs);
 fail(msg);
 }
 }

 /**
 * Shorthand for {@link #assertGreaterThan(Comparable, Comparable)}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertGreaterThan(Comparable, Comparable)
 */
 public static <T extends Comparable<T>> void assertGT(T lhs, T rhs) {
 assertGreaterThan(lhs, rhs);
 }

 /**
 * Shorthand for {@link #assertGreaterThan(Comparable, Comparable, String)}.
 *
 * @param <T> a type
 * @param lhs the left hand value
 * @param rhs the right hand value
 * @param msg A description of the assumption; {@code null} for a default message.
 * @see #assertGreaterThan(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertGT(T lhs, T rhs, String msg) {
 assertGreaterThan(lhs, rhs, msg);
 }

 /**
 * Calls {@link #assertGreaterThan(Comparable, Comparable, String)} with a default message.
 *
 * @param <T> a type
 * @param lhs the left hand value
 * @param rhs the right hand value
 * @see #assertGreaterThan(Comparable, Comparable, String)
 */
 public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs) {
 assertGreaterThan(lhs, rhs, null);
 }

 /**
 * Asserts that {@code lhs} is greater than {@code rhs}.
 *
 * @param <T> a type
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs, String msg) {
 if (!(compare(lhs, rhs, msg) > 0)) {
 msg = Objects.toString(msg, "assertGreaterThan")
 + ": expected " + Objects.toString(lhs)
 + " > " + Objects.toString(rhs);
 fail(msg);
 }
 }

 /**
 * Shorthand for {@link #assertNotEquals(Object, Object)}.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertNotEquals(Object, Object)
 */
 public static void assertNE(Object lhs, Object rhs) {
 assertNotEquals(lhs, rhs);
 }

 /**
 * Shorthand for {@link #assertNotEquals(Object, Object, String)}.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @see #assertNotEquals(Object, Object, String)
 */
 public static void assertNE(Object lhs, Object rhs, String msg) {
 assertNotEquals(lhs, rhs, msg);
 }

 /**
 * Calls {@link #assertNotEquals(Object, Object, String)} with a default message.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @see #assertNotEquals(Object, Object, String)
 */
 public static void assertNotEquals(Object lhs, Object rhs) {
 assertNotEquals(lhs, rhs, null);
 }

 /**
 * Asserts that {@code lhs} is not equal to {@code rhs}.
 *
 * @param lhs The left hand side of the comparison.
 * @param rhs The right hand side of the comparison.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static void assertNotEquals(Object lhs, Object rhs, String msg) {
 if ((lhs == rhs) || (lhs != null && lhs.equals(rhs))) {
 msg = Objects.toString(msg, "assertNotEquals")
 + ": expected " + Objects.toString(lhs)
 + " to not equal " + Objects.toString(rhs);
 fail(msg);
 }
 }

 /**
 * Calls {@link #assertNull(Object, String)} with a default message.
 *
 * @param o The reference assumed to be null.
 * @see #assertNull(Object, String)
 */
 public static void assertNull(Object o) {
 assertNull(o, null);
 }

 /**
 * Asserts that {@code o} is null.
 *
 * @param o The reference assumed to be null.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static void assertNull(Object o, String msg) {
 assertEquals(o, null, msg);
 }

 /**
 * Calls {@link #assertNotNull(Object, String)} with a default message.
 *
 * @param o The reference assumed not to be null,
 * @see #assertNotNull(Object, String)
 */
 public static void assertNotNull(Object o) {
 assertNotNull(o, null);
 }

 /**
 * Asserts that {@code o} is not null.
 *
 * @param o The reference assumed not to be null,
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static void assertNotNull(Object o, String msg) {
 assertNotEquals(o, null, msg);
 }

 /**
 * Calls {@link #assertFalse(boolean, String)} with a default message.
 *
 * @param value The value assumed to be false.
 * @see #assertFalse(boolean, String)
 */
 public static void assertFalse(boolean value) {
 assertFalse(value, null);
 }

 /**
 * Asserts that {@code value} is {@code false}.
 *
 * @param value The value assumed to be false.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static void assertFalse(boolean value, String msg) {
 if (value) {
 msg = Objects.toString(msg, "assertFalse")
 + ": expected false, was true";
 fail(msg);
 }
 }

 /**
 * Calls {@link #assertTrue(boolean, String)} with a default message.
 *
 * @param value The value assumed to be true.
 * @see #assertTrue(boolean, String)
 */
 public static void assertTrue(boolean value) {
 assertTrue(value, null);
 }

 /**
 * Asserts that {@code value} is {@code true}.
 *
 * @param value The value assumed to be true.
 * @param msg A description of the assumption; {@code null} for a default message.
 * @throws RuntimeException if the assertion is not true.
 */
 public static void assertTrue(boolean value, String msg) {
 if (!value) {
 msg = Objects.toString(msg, "assertTrue")
 + ": expected true, was false";
 fail(msg);
 }
 }

 private static <T extends Comparable<T>> int compare(T lhs, T rhs, String msg) {
 if (lhs == null || rhs == null) {
 fail(lhs, rhs, msg + ": values must be non-null:", ",");
 }
 return lhs.compareTo(rhs);
 }

/**
 * Asserts that two strings are equal.
 *
 * If strings are not equals, then exception message
 * will contain {@code msg} followed by list of mismatched lines.
 *
 * @param str1 First string to compare.
 * @param str2 Second string to compare.
 * @param msg A description of the assumption.
 * @throws RuntimeException if strings are not equal.
 */
 public static void assertStringsEqual(String str1, String str2,
 String msg) {
 String lineSeparator = System.getProperty("line.separator");
 String str1Lines[] = str1.split(lineSeparator);
 String str2Lines[] = str2.split(lineSeparator);

 int minLength = Math.min(str1Lines.length, str2Lines.length);
 String longestStringLines[] = ((str1Lines.length == minLength) ?
 str2Lines : str1Lines);

 boolean stringsAreDifferent = false;

 StringBuilder messageBuilder = new StringBuilder(msg);

 messageBuilder.append("\n");

 for (int line = 0; line < minLength; line++) {
 if (!str1Lines[line].equals(str2Lines[line])) {
 messageBuilder.append(String.
 format("[line %d] '%s' differs " +
 "from '%s'\n",
 line,
 str1Lines[line],
 str2Lines[line]));
 stringsAreDifferent = true;
 }
 }

 if (minLength < longestStringLines.length) {
 String stringName = ((longestStringLines == str1Lines) ?
 "first" : "second");
 messageBuilder.append(String.format("Only %s string contains " +
 "following lines:\n",
 stringName));
 stringsAreDifferent = true;
 for(int line = minLength; line < longestStringLines.length; line++) {
 messageBuilder.append(String.
 format("[line %d] '%s'", line,
 longestStringLines[line]));
 }
 }

 if (stringsAreDifferent) {
 fail(messageBuilder.toString());
 }
 }

 /**
 * Returns a string formatted with a message and expected and actual values.
 * @param lhs the actual value
 * @param rhs the expected value
 * @param message the actual value
 * @param relation the asserted relationship between lhs and rhs
 * @return a formatted string
 */
 public static String format(Object lhs, Object rhs, String message, String relation) {
 StringBuilder sb = new StringBuilder(80);
 if (message != null) {
 sb.append(message);
 sb.append(' ');
 }
 sb.append("<");
 sb.append(Objects.toString(lhs));
 sb.append("> ");
 sb.append(Objects.toString(relation, ","));
 sb.append(" <");
 sb.append(Objects.toString(rhs));
 sb.append(">");
 return sb.toString();
 }

 /**
 * Fail reports a failure with message fail.
 *
 * @throws RuntimeException always
 */
 public static void fail() {
 fail("fail");
 }

 /**
 * Fail reports a failure with a message.
 * @param message for the failure
 * @throws RuntimeException always
 */
 public static void fail(String message) {
 throw new RuntimeException(message);
 }

 /**
 * Fail reports a failure with a formatted message.
 *
 * @param lhs the actual value
 * @param rhs the expected value
 * @param message to be format before the expected and actual values
 * @param relation the asserted relationship between lhs and rhs
 * @throws RuntimeException always
 */
 public static void fail(Object lhs, Object rhs, String message, String relation) {
 throw new RuntimeException(format(lhs, rhs, message, relation));
 }

 /**
 * Fail reports a failure with a message and a cause.
 * @param message to be format before the expected and actual values
 * @param cause the exception that caused this failure
 * @throws RuntimeException always
 */
 public static void fail(String message, Throwable cause) {
 throw new RuntimeException(message, cause);
 }

}

¤ Dauer der Verarbeitung: 0.22 Sekunden (vorverarbeitet) ¤

Download des Quellennavigators
Download des sprechenden Kalenders
in der Quellcodebibliothek suchen

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.