hotspot/src/jdk.vm.compiler/share/classes/org.graalvm.compiler.test/src/org/graalvm/compiler/test/GraalTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2013, 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 org.graalvm.compiler.test;

 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Arrays;

 import org.junit.Assert;
 import org.junit.internal.ComparisonCriteria;
 import org.junit.internal.ExactComparisonCriteria;

 import sun.misc.Unsafe;

 /**
  * Base class that contains common utility methods and classes useful in unit tests.
  */
 public class GraalTest {

     public static final Unsafe UNSAFE;
     static {
         try {
             Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
             theUnsafe.setAccessible(true);
             UNSAFE = (Unsafe) theUnsafe.get(Unsafe.class);
         } catch (Exception e) {
             throw new RuntimeException("exception while trying to get Unsafe", e);
         }
     }

     public static final boolean Java8OrEarlier = System.getProperty("java.specification.version").compareTo("1.9") < 0;

     protected Method getMethod(String methodName) {
         return getMethod(getClass(), methodName);
     }

     protected Method getMethod(Class<?> clazz, String methodName) {
         Method found = null;
         for (Method m : clazz.getMethods()) {
             if (m.getName().equals(methodName)) {
                 Assert.assertNull(found);
                 found = m;
             }
         }
         if (found == null) {
             /* Now look for non-public methods (but this does not look in superclasses). */
             for (Method m : clazz.getDeclaredMethods()) {
                 if (m.getName().equals(methodName)) {
                     Assert.assertNull(found);
                     found = m;
                 }
             }
         }
         if (found != null) {
             return found;
         } else {
             throw new RuntimeException("method not found: " + methodName);
         }
     }

     protected Method getMethod(Class<?> clazz, String methodName, Class<?>[] parameterTypes) {
         try {
             return clazz.getMethod(methodName, parameterTypes);
         } catch (NoSuchMethodException | SecurityException e) {
             throw new RuntimeException("method not found: " + methodName + "" + Arrays.toString(parameterTypes));
         }
     }

     /**
      * Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
      * Does a deep copy equality comparison if {@code expected} is an array.
      */
     protected void assertDeepEquals(Object expected, Object actual) {
         assertDeepEquals(null, expected, actual);
     }

     /**
      * Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
      * Does a deep copy equality comparison if {@code expected} is an array.
      *
      * @param message the identifying message for the {@link AssertionError}
      */
     protected void assertDeepEquals(String message, Object expected, Object actual) {
         if (ulpsDelta() > 0) {
             assertDeepEquals(message, expected, actual, ulpsDelta());
         } else {
             assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
         }
     }

     /**
      * Compares two given values for equality, doing a recursive test if both values are arrays of
      * the same type.
      *
      * @param message the identifying message for the {@link AssertionError}
      * @param delta the maximum delta between two doubles or floats for which both numbers are still
      *            considered equal.
      */
     protected void assertDeepEquals(String message, Object expected, Object actual, double delta) {
         if (expected != null && actual != null) {
             Class<?> expectedClass = expected.getClass();
             Class<?> actualClass = actual.getClass();
             if (expectedClass.isArray()) {
                 Assert.assertTrue(message, expected != null);
                 Assert.assertTrue(message, actual != null);
                 Assert.assertEquals(message, expectedClass, actual.getClass());
                 if (expected instanceof int[]) {
                     Assert.assertArrayEquals(message, (int[]) expected, (int[]) actual);
                 } else if (expected instanceof byte[]) {
                     Assert.assertArrayEquals(message, (byte[]) expected, (byte[]) actual);
                 } else if (expected instanceof char[]) {
                     Assert.assertArrayEquals(message, (char[]) expected, (char[]) actual);
                 } else if (expected instanceof short[]) {
                     Assert.assertArrayEquals(message, (short[]) expected, (short[]) actual);
                 } else if (expected instanceof float[]) {
                     Assert.assertArrayEquals(message, (float[]) expected, (float[]) actual, (float) delta);
                 } else if (expected instanceof long[]) {
                     Assert.assertArrayEquals(message, (long[]) expected, (long[]) actual);
                 } else if (expected instanceof double[]) {
                     Assert.assertArrayEquals(message, (double[]) expected, (double[]) actual, delta);
                 } else if (expected instanceof boolean[]) {
                     new ExactComparisonCriteria().arrayEquals(message, expected, actual);
                 } else if (expected instanceof Object[]) {
                     new ComparisonCriteria() {
                         @Override
                         protected void assertElementsEqual(Object e, Object a) {
                             assertDeepEquals(message, e, a, delta);
                         }
                     }.arrayEquals(message, expected, actual);
                 } else {
                     Assert.fail((message == null ? "" : message) + "non-array value encountered: " + expected);
                 }
             } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
                 Assert.assertEquals((double) expected, (double) actual, delta);
             } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
                 Assert.assertEquals((float) expected, (float) actual, delta);
             } else {
                 Assert.assertEquals(message, expected, actual);
             }
         } else {
             Assert.assertEquals(message, expected, actual);
         }
     }

     /**
      * Compares two given values for equality, doing a recursive test if both values are arrays of
      * the same type. Uses {@linkplain StrictMath#ulp(float) ULP}s for comparison of floats.
      *
      * @param message the identifying message for the {@link AssertionError}
      * @param ulpsDelta the maximum allowed ulps difference between two doubles or floats for which
      *            both numbers are still considered equal.
      */
     protected void assertDeepEquals(String message, Object expected, Object actual, int ulpsDelta) {
         ComparisonCriteria doubleUlpsDeltaCriteria = new ComparisonCriteria() {
             @Override
             protected void assertElementsEqual(Object e, Object a) {
                 assertTrue(message, e instanceof Double && a instanceof Double);
                 // determine acceptable error based on whether it is a normal number or a NaN/Inf
                 double de = (Double) e;
                 double epsilon = (!Double.isNaN(de) && Double.isFinite(de) ? ulpsDelta * Math.ulp(de) : 0);
                 Assert.assertEquals(message, (Double) e, (Double) a, epsilon);
             }
         };

         ComparisonCriteria floatUlpsDeltaCriteria = new ComparisonCriteria() {
             @Override
             protected void assertElementsEqual(Object e, Object a) {
                 assertTrue(message, e instanceof Float && a instanceof Float);
                 // determine acceptable error based on whether it is a normal number or a NaN/Inf
                 float fe = (Float) e;
                 float epsilon = (!Float.isNaN(fe) && Float.isFinite(fe) ? ulpsDelta * Math.ulp(fe) : 0);
                 Assert.assertEquals(message, (Float) e, (Float) a, epsilon);
             }
         };

         if (expected != null && actual != null) {
             Class<?> expectedClass = expected.getClass();
             Class<?> actualClass = actual.getClass();
             if (expectedClass.isArray()) {
                 Assert.assertEquals(message, expectedClass, actualClass);
                 if (expected instanceof double[] || expected instanceof Object[]) {
                     doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
                     return;
                 } else if (expected instanceof float[] || expected instanceof Object[]) {
                     floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
                     return;
                 }
             } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
                 doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
                 return;
             } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
                 floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
                 return;
             }
         }
         // anything else just use the non-ulps version
         assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
     }

     /**
      * Gets the value used by {@link #assertDeepEquals(Object, Object)} and
      * {@link #assertDeepEquals(String, Object, Object)} for the maximum delta between two doubles
      * or floats for which both numbers are still considered equal.
      */
     protected double equalFloatsOrDoublesDelta() {
         return 0.0D;
     }

     // unless overridden ulpsDelta is not used
     protected int ulpsDelta() {
         return 0;
     }

     @SuppressWarnings("serial")
     public static class MultiCauseAssertionError extends AssertionError {

         private Throwable[] causes;

         public MultiCauseAssertionError(String message, Throwable... causes) {
             super(message);
             this.causes = causes;
         }

         @Override
         public void printStackTrace(PrintStream out) {
             super.printStackTrace(out);
             int num = 0;
             for (Throwable cause : causes) {
                 if (cause != null) {
                     out.print("cause " + (num++));
                     cause.printStackTrace(out);
                 }
             }
         }

         @Override
         public void printStackTrace(PrintWriter out) {
             super.printStackTrace(out);
             int num = 0;
             for (Throwable cause : causes) {
                 if (cause != null) {
                     out.print("cause " + (num++) + ": ");
                     cause.printStackTrace(out);
                 }
             }
         }
     }

     /*
      * Overrides to the normal JUnit {@link Assert} routines that provide varargs style formatting
      * and produce an exception stack trace with the assertion frames trimmed out.
      */

     /**
      * Fails a test with the given message.
      *
      * @param message the identifying message for the {@link AssertionError} (<code>null</code>
      *            okay)
      * @see AssertionError
      */
     public static void fail(String message, Object... objects) {
         AssertionError e;
         if (message == null) {
             e = new AssertionError();
         } else {
             e = new AssertionError(String.format(message, objects));
         }
         // Trim the assert frames from the stack trace
         StackTraceElement[] trace = e.getStackTrace();
         int start = 1; // Skip this frame
         String thisClassName = GraalTest.class.getName();
         while (start < trace.length && trace[start].getClassName().equals(thisClassName) && (trace[start].getMethodName().equals("assertTrue") || trace[start].getMethodName().equals("assertFalse"))) {
             start++;
         }
         e.setStackTrace(Arrays.copyOfRange(trace, start, trace.length));
         throw e;
     }

     /**
      * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
      * given message.
      *
      * @param message the identifying message for the {@link AssertionError} (<code>null</code>
      *            okay)
      * @param condition condition to be checked
      */
     public static void assertTrue(String message, boolean condition) {
         assertTrue(condition, message);
     }

     /**
      * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} without a
      * message.
      *
      * @param condition condition to be checked
      */
     public static void assertTrue(boolean condition) {
         assertTrue(condition, null);
     }

     /**
      * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
      * given message.
      *
      * @param message the identifying message for the {@link AssertionError} (<code>null</code>
      *            okay)
      * @param condition condition to be checked
      */
     public static void assertFalse(String message, boolean condition) {
         assertTrue(!condition, message);
     }

     /**
      * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} without a
      * message.
      *
      * @param condition condition to be checked
      */
     public static void assertFalse(boolean condition) {
         assertTrue(!condition, null);
     }

     /**
      * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
      * given message.
      *
      * @param condition condition to be checked
      * @param message the identifying message for the {@link AssertionError}
      * @param objects arguments to the format string
      */
     public static void assertTrue(boolean condition, String message, Object... objects) {
         if (!condition) {
             fail(message, objects);
         }
     }

     /**
      * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
      * given message produced by {@link String#format}.
      *
      * @param condition condition to be checked
      * @param message the identifying message for the {@link AssertionError}
      * @param objects arguments to the format string
      */
     public static void assertFalse(boolean condition, String message, Object... objects) {
         assertTrue(!condition, message, objects);
     }
 }
	/*
	* Copyright (c) 2013, 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 org.graalvm.compiler.test;

	import java.io.PrintStream;
	import java.io.PrintWriter;
	import java.lang.reflect.Field;
	import java.lang.reflect.Method;
	import java.util.Arrays;

	import org.junit.Assert;
	import org.junit.internal.ComparisonCriteria;
	import org.junit.internal.ExactComparisonCriteria;

	import sun.misc.Unsafe;

	/**
	* Base class that contains common utility methods and classes useful in unit tests.
	*/
	public class GraalTest {

	public static final Unsafe UNSAFE;
	static {
	try {
	Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
	theUnsafe.setAccessible(true);
	UNSAFE = (Unsafe) theUnsafe.get(Unsafe.class);
	} catch (Exception e) {
	throw new RuntimeException("exception while trying to get Unsafe", e);
	}
	}

	public static final boolean Java8OrEarlier = System.getProperty("java.specification.version").compareTo("1.9") < 0;

	protected Method getMethod(String methodName) {
	return getMethod(getClass(), methodName);
	}

	protected Method getMethod(Class<?> clazz, String methodName) {
	Method found = null;
	for (Method m : clazz.getMethods()) {
	if (m.getName().equals(methodName)) {
	Assert.assertNull(found);
	found = m;
	}
	}
	if (found == null) {
	/* Now look for non-public methods (but this does not look in superclasses). */
	for (Method m : clazz.getDeclaredMethods()) {
	if (m.getName().equals(methodName)) {
	Assert.assertNull(found);
	found = m;
	}
	}
	}
	if (found != null) {
	return found;
	} else {
	throw new RuntimeException("method not found: " + methodName);
	}
	}

	protected Method getMethod(Class<?> clazz, String methodName, Class<?>[] parameterTypes) {
	try {
	return clazz.getMethod(methodName, parameterTypes);
	} catch (NoSuchMethodException \| SecurityException e) {
	throw new RuntimeException("method not found: " + methodName + "" + Arrays.toString(parameterTypes));
	}
	}

	/**
	* Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
	* Does a deep copy equality comparison if {@code expected} is an array.
	*/
	protected void assertDeepEquals(Object expected, Object actual) {
	assertDeepEquals(null, expected, actual);
	}

	/**
	* Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
	* Does a deep copy equality comparison if {@code expected} is an array.
	*
	* @param message the identifying message for the {@link AssertionError}
	*/
	protected void assertDeepEquals(String message, Object expected, Object actual) {
	if (ulpsDelta() > 0) {
	assertDeepEquals(message, expected, actual, ulpsDelta());
	} else {
	assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
	}
	}

	/**
	* Compares two given values for equality, doing a recursive test if both values are arrays of
	* the same type.
	*
	* @param message the identifying message for the {@link AssertionError}
	* @param delta the maximum delta between two doubles or floats for which both numbers are still
	* considered equal.
	*/
	protected void assertDeepEquals(String message, Object expected, Object actual, double delta) {
	if (expected != null && actual != null) {
	Class<?> expectedClass = expected.getClass();
	Class<?> actualClass = actual.getClass();
	if (expectedClass.isArray()) {
	Assert.assertTrue(message, expected != null);
	Assert.assertTrue(message, actual != null);
	Assert.assertEquals(message, expectedClass, actual.getClass());
	if (expected instanceof int[]) {
	Assert.assertArrayEquals(message, (int[]) expected, (int[]) actual);
	} else if (expected instanceof byte[]) {
	Assert.assertArrayEquals(message, (byte[]) expected, (byte[]) actual);
	} else if (expected instanceof char[]) {
	Assert.assertArrayEquals(message, (char[]) expected, (char[]) actual);
	} else if (expected instanceof short[]) {
	Assert.assertArrayEquals(message, (short[]) expected, (short[]) actual);
	} else if (expected instanceof float[]) {
	Assert.assertArrayEquals(message, (float[]) expected, (float[]) actual, (float) delta);
	} else if (expected instanceof long[]) {
	Assert.assertArrayEquals(message, (long[]) expected, (long[]) actual);
	} else if (expected instanceof double[]) {
	Assert.assertArrayEquals(message, (double[]) expected, (double[]) actual, delta);
	} else if (expected instanceof boolean[]) {
	new ExactComparisonCriteria().arrayEquals(message, expected, actual);
	} else if (expected instanceof Object[]) {
	new ComparisonCriteria() {
	@Override
	protected void assertElementsEqual(Object e, Object a) {
	assertDeepEquals(message, e, a, delta);
	}
	}.arrayEquals(message, expected, actual);
	} else {
	Assert.fail((message == null ? "" : message) + "non-array value encountered: " + expected);
	}
	} else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
	Assert.assertEquals((double) expected, (double) actual, delta);
	} else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
	Assert.assertEquals((float) expected, (float) actual, delta);
	} else {
	Assert.assertEquals(message, expected, actual);
	}
	} else {
	Assert.assertEquals(message, expected, actual);
	}
	}

	/**
	* Compares two given values for equality, doing a recursive test if both values are arrays of
	* the same type. Uses {@linkplain StrictMath#ulp(float) ULP}s for comparison of floats.
	*
	* @param message the identifying message for the {@link AssertionError}
	* @param ulpsDelta the maximum allowed ulps difference between two doubles or floats for which
	* both numbers are still considered equal.
	*/
	protected void assertDeepEquals(String message, Object expected, Object actual, int ulpsDelta) {
	ComparisonCriteria doubleUlpsDeltaCriteria = new ComparisonCriteria() {
	@Override
	protected void assertElementsEqual(Object e, Object a) {
	assertTrue(message, e instanceof Double && a instanceof Double);
	// determine acceptable error based on whether it is a normal number or a NaN/Inf
	double de = (Double) e;
	double epsilon = (!Double.isNaN(de) && Double.isFinite(de) ? ulpsDelta * Math.ulp(de) : 0);
	Assert.assertEquals(message, (Double) e, (Double) a, epsilon);
	}
	};

	ComparisonCriteria floatUlpsDeltaCriteria = new ComparisonCriteria() {
	@Override
	protected void assertElementsEqual(Object e, Object a) {
	assertTrue(message, e instanceof Float && a instanceof Float);
	// determine acceptable error based on whether it is a normal number or a NaN/Inf
	float fe = (Float) e;
	float epsilon = (!Float.isNaN(fe) && Float.isFinite(fe) ? ulpsDelta * Math.ulp(fe) : 0);
	Assert.assertEquals(message, (Float) e, (Float) a, epsilon);
	}
	};

	if (expected != null && actual != null) {
	Class<?> expectedClass = expected.getClass();
	Class<?> actualClass = actual.getClass();
	if (expectedClass.isArray()) {
	Assert.assertEquals(message, expectedClass, actualClass);
	if (expected instanceof double[] \|\| expected instanceof Object[]) {
	doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
	return;
	} else if (expected instanceof float[] \|\| expected instanceof Object[]) {
	floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
	return;
	}
	} else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
	doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
	return;
	} else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
	floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
	return;
	}
	}
	// anything else just use the non-ulps version
	assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
	}

	/**
	* Gets the value used by {@link #assertDeepEquals(Object, Object)} and
	* {@link #assertDeepEquals(String, Object, Object)} for the maximum delta between two doubles
	* or floats for which both numbers are still considered equal.
	*/
	protected double equalFloatsOrDoublesDelta() {
	return 0.0D;
	}

	// unless overridden ulpsDelta is not used
	protected int ulpsDelta() {
	return 0;
	}

	@SuppressWarnings("serial")
	public static class MultiCauseAssertionError extends AssertionError {

	private Throwable[] causes;

	public MultiCauseAssertionError(String message, Throwable... causes) {
	super(message);
	this.causes = causes;
	}

	@Override
	public void printStackTrace(PrintStream out) {
	super.printStackTrace(out);
	int num = 0;
	for (Throwable cause : causes) {
	if (cause != null) {
	out.print("cause " + (num++));
	cause.printStackTrace(out);
	}
	}
	}

	@Override
	public void printStackTrace(PrintWriter out) {
	super.printStackTrace(out);
	int num = 0;
	for (Throwable cause : causes) {
	if (cause != null) {
	out.print("cause " + (num++) + ": ");
	cause.printStackTrace(out);
	}
	}
	}
	}

	/*
	* Overrides to the normal JUnit {@link Assert} routines that provide varargs style formatting
	* and produce an exception stack trace with the assertion frames trimmed out.
	*/

	/**
	* Fails a test with the given message.
	*
	* @param message the identifying message for the {@link AssertionError} (<code>null</code>
	* okay)
	* @see AssertionError
	*/
	public static void fail(String message, Object... objects) {
	AssertionError e;
	if (message == null) {
	e = new AssertionError();
	} else {
	e = new AssertionError(String.format(message, objects));
	}
	// Trim the assert frames from the stack trace
	StackTraceElement[] trace = e.getStackTrace();
	int start = 1; // Skip this frame
	String thisClassName = GraalTest.class.getName();
	while (start < trace.length && trace[start].getClassName().equals(thisClassName) && (trace[start].getMethodName().equals("assertTrue") \|\| trace[start].getMethodName().equals("assertFalse"))) {
	start++;
	}
	e.setStackTrace(Arrays.copyOfRange(trace, start, trace.length));
	throw e;
	}

	/**
	* Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
	* given message.
	*
	* @param message the identifying message for the {@link AssertionError} (<code>null</code>
	* okay)
	* @param condition condition to be checked
	*/
	public static void assertTrue(String message, boolean condition) {
	assertTrue(condition, message);
	}

	/**
	* Asserts that a condition is true. If it isn't it throws an {@link AssertionError} without a
	* message.
	*
	* @param condition condition to be checked
	*/
	public static void assertTrue(boolean condition) {
	assertTrue(condition, null);
	}

	/**
	* Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
	* given message.
	*
	* @param message the identifying message for the {@link AssertionError} (<code>null</code>
	* okay)
	* @param condition condition to be checked
	*/
	public static void assertFalse(String message, boolean condition) {
	assertTrue(!condition, message);
	}

	/**
	* Asserts that a condition is false. If it isn't it throws an {@link AssertionError} without a
	* message.
	*
	* @param condition condition to be checked
	*/
	public static void assertFalse(boolean condition) {
	assertTrue(!condition, null);
	}

	/**
	* Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
	* given message.
	*
	* @param condition condition to be checked
	* @param message the identifying message for the {@link AssertionError}
	* @param objects arguments to the format string
	*/
	public static void assertTrue(boolean condition, String message, Object... objects) {
	if (!condition) {
	fail(message, objects);
	}
	}

	/**
	* Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
	* given message produced by {@link String#format}.
	*
	* @param condition condition to be checked
	* @param message the identifying message for the {@link AssertionError}
	* @param objects arguments to the format string
	*/
	public static void assertFalse(boolean condition, String message, Object... objects) {
	assertTrue(!condition, message, objects);
	}
	}