1 /*
   2  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.test;
  24 
  25 import static org.graalvm.compiler.debug.DebugContext.DEFAULT_LOG_STREAM;
  26 import static org.graalvm.compiler.debug.DebugContext.NO_DESCRIPTION;
  27 import static org.graalvm.compiler.debug.DebugContext.NO_GLOBAL_METRIC_VALUES;
  28 
  29 import java.io.PrintStream;
  30 import java.io.PrintWriter;
  31 import java.lang.reflect.Field;
  32 import java.lang.reflect.Method;
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.Collection;
  36 import java.util.Collections;
  37 import java.util.List;
  38 
  39 import jdk.vm.ci.meta.ResolvedJavaMethod;
  40 import org.graalvm.compiler.debug.DebugHandlersFactory;
  41 import org.graalvm.compiler.debug.DebugContext;
  42 import org.graalvm.compiler.debug.DebugDumpHandler;
  43 import org.graalvm.compiler.options.OptionValues;
  44 import org.junit.After;
  45 import org.junit.Assert;
  46 import org.junit.internal.ComparisonCriteria;
  47 import org.junit.internal.ExactComparisonCriteria;
  48 
  49 import sun.misc.Unsafe;
  50 
  51 /**
  52  * Base class that contains common utility methods and classes useful in unit tests.
  53  */
  54 public class GraalTest {
  55 
  56     public static final Unsafe UNSAFE;
  57     static {
  58         try {
  59             Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
  60             theUnsafe.setAccessible(true);
  61             UNSAFE = (Unsafe) theUnsafe.get(Unsafe.class);
  62         } catch (Exception e) {
  63             throw new RuntimeException("exception while trying to get Unsafe", e);
  64         }
  65     }
  66 
  67     public static final boolean Java8OrEarlier = System.getProperty("java.specification.version").compareTo("1.9") < 0;
  68 
  69     protected Method getMethod(String methodName) {
  70         return getMethod(getClass(), methodName);
  71     }
  72 
  73     protected Method getMethod(Class<?> clazz, String methodName) {
  74         Method found = null;
  75         for (Method m : clazz.getMethods()) {
  76             if (m.getName().equals(methodName)) {
  77                 Assert.assertNull(found);
  78                 found = m;
  79             }
  80         }
  81         if (found == null) {
  82             /* Now look for non-public methods (but this does not look in superclasses). */
  83             for (Method m : clazz.getDeclaredMethods()) {
  84                 if (m.getName().equals(methodName)) {
  85                     Assert.assertNull(found);
  86                     found = m;
  87                 }
  88             }
  89         }
  90         if (found != null) {
  91             return found;
  92         } else {
  93             throw new RuntimeException("method not found: " + methodName);
  94         }
  95     }
  96 
  97     protected Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
  98         try {
  99             return clazz.getMethod(methodName, parameterTypes);
 100         } catch (NoSuchMethodException | SecurityException e) {
 101             throw new RuntimeException("method not found: " + methodName + "" + Arrays.toString(parameterTypes));
 102         }
 103     }
 104 
 105     /**
 106      * Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
 107      * Does a deep copy equality comparison if {@code expected} is an array.
 108      */
 109     protected void assertDeepEquals(Object expected, Object actual) {
 110         assertDeepEquals(null, expected, actual);
 111     }
 112 
 113     /**
 114      * Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
 115      * Does a deep copy equality comparison if {@code expected} is an array.
 116      *
 117      * @param message the identifying message for the {@link AssertionError}
 118      */
 119     protected void assertDeepEquals(String message, Object expected, Object actual) {
 120         if (ulpsDelta() > 0) {
 121             assertDeepEquals(message, expected, actual, ulpsDelta());
 122         } else {
 123             assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
 124         }
 125     }
 126 
 127     /**
 128      * Compares two given values for equality, doing a recursive test if both values are arrays of
 129      * the same type.
 130      *
 131      * @param message the identifying message for the {@link AssertionError}
 132      * @param delta the maximum delta between two doubles or floats for which both numbers are still
 133      *            considered equal.
 134      */
 135     protected void assertDeepEquals(String message, Object expected, Object actual, double delta) {
 136         if (expected != null && actual != null) {
 137             Class<?> expectedClass = expected.getClass();
 138             Class<?> actualClass = actual.getClass();
 139             if (expectedClass.isArray()) {
 140                 Assert.assertEquals(message, expectedClass, actual.getClass());
 141                 if (expected instanceof int[]) {
 142                     Assert.assertArrayEquals(message, (int[]) expected, (int[]) actual);
 143                 } else if (expected instanceof byte[]) {
 144                     Assert.assertArrayEquals(message, (byte[]) expected, (byte[]) actual);
 145                 } else if (expected instanceof char[]) {
 146                     Assert.assertArrayEquals(message, (char[]) expected, (char[]) actual);
 147                 } else if (expected instanceof short[]) {
 148                     Assert.assertArrayEquals(message, (short[]) expected, (short[]) actual);
 149                 } else if (expected instanceof float[]) {
 150                     Assert.assertArrayEquals(message, (float[]) expected, (float[]) actual, (float) delta);
 151                 } else if (expected instanceof long[]) {
 152                     Assert.assertArrayEquals(message, (long[]) expected, (long[]) actual);
 153                 } else if (expected instanceof double[]) {
 154                     Assert.assertArrayEquals(message, (double[]) expected, (double[]) actual, delta);
 155                 } else if (expected instanceof boolean[]) {
 156                     new ExactComparisonCriteria().arrayEquals(message, expected, actual);
 157                 } else if (expected instanceof Object[]) {
 158                     new ComparisonCriteria() {
 159                         @Override
 160                         protected void assertElementsEqual(Object e, Object a) {
 161                             assertDeepEquals(message, e, a, delta);
 162                         }
 163                     }.arrayEquals(message, expected, actual);
 164                 } else {
 165                     Assert.fail((message == null ? "" : message) + "non-array value encountered: " + expected);
 166                 }
 167             } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
 168                 Assert.assertEquals((double) expected, (double) actual, delta);
 169             } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
 170                 Assert.assertEquals((float) expected, (float) actual, delta);
 171             } else {
 172                 Assert.assertEquals(message, expected, actual);
 173             }
 174         } else {
 175             Assert.assertEquals(message, expected, actual);
 176         }
 177     }
 178 
 179     /**
 180      * Compares two given values for equality, doing a recursive test if both values are arrays of
 181      * the same type. Uses {@linkplain StrictMath#ulp(float) ULP}s for comparison of floats.
 182      *
 183      * @param message the identifying message for the {@link AssertionError}
 184      * @param ulpsDelta the maximum allowed ulps difference between two doubles or floats for which
 185      *            both numbers are still considered equal.
 186      */
 187     protected void assertDeepEquals(String message, Object expected, Object actual, int ulpsDelta) {
 188         ComparisonCriteria doubleUlpsDeltaCriteria = new ComparisonCriteria() {
 189             @Override
 190             protected void assertElementsEqual(Object e, Object a) {
 191                 assertTrue(message, e instanceof Double && a instanceof Double);
 192                 // determine acceptable error based on whether it is a normal number or a NaN/Inf
 193                 double de = (Double) e;
 194                 double epsilon = (!Double.isNaN(de) && Double.isFinite(de) ? ulpsDelta * Math.ulp(de) : 0);
 195                 Assert.assertEquals(message, (Double) e, (Double) a, epsilon);
 196             }
 197         };
 198 
 199         ComparisonCriteria floatUlpsDeltaCriteria = new ComparisonCriteria() {
 200             @Override
 201             protected void assertElementsEqual(Object e, Object a) {
 202                 assertTrue(message, e instanceof Float && a instanceof Float);
 203                 // determine acceptable error based on whether it is a normal number or a NaN/Inf
 204                 float fe = (Float) e;
 205                 float epsilon = (!Float.isNaN(fe) && Float.isFinite(fe) ? ulpsDelta * Math.ulp(fe) : 0);
 206                 Assert.assertEquals(message, (Float) e, (Float) a, epsilon);
 207             }
 208         };
 209 
 210         if (expected != null && actual != null) {
 211             Class<?> expectedClass = expected.getClass();
 212             Class<?> actualClass = actual.getClass();
 213             if (expectedClass.isArray()) {
 214                 Assert.assertEquals(message, expectedClass, actualClass);
 215                 if (expected instanceof double[] || expected instanceof Object[]) {
 216                     doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
 217                     return;
 218                 } else if (expected instanceof float[] || expected instanceof Object[]) {
 219                     floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
 220                     return;
 221                 }
 222             } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
 223                 doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
 224                 return;
 225             } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
 226                 floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
 227                 return;
 228             }
 229         }
 230         // anything else just use the non-ulps version
 231         assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
 232     }
 233 
 234     /**
 235      * Gets the value used by {@link #assertDeepEquals(Object, Object)} and
 236      * {@link #assertDeepEquals(String, Object, Object)} for the maximum delta between two doubles
 237      * or floats for which both numbers are still considered equal.
 238      */
 239     protected double equalFloatsOrDoublesDelta() {
 240         return 0.0D;
 241     }
 242 
 243     // unless overridden ulpsDelta is not used
 244     protected int ulpsDelta() {
 245         return 0;
 246     }
 247 
 248     @SuppressWarnings("serial")
 249     public static class MultiCauseAssertionError extends AssertionError {
 250 
 251         private Throwable[] causes;
 252 
 253         public MultiCauseAssertionError(String message, Throwable... causes) {
 254             super(message);
 255             this.causes = causes;
 256         }
 257 
 258         @Override
 259         public void printStackTrace(PrintStream out) {
 260             super.printStackTrace(out);
 261             int num = 0;
 262             for (Throwable cause : causes) {
 263                 if (cause != null) {
 264                     out.print("cause " + (num++));
 265                     cause.printStackTrace(out);
 266                 }
 267             }
 268         }
 269 
 270         @Override
 271         public void printStackTrace(PrintWriter out) {
 272             super.printStackTrace(out);
 273             int num = 0;
 274             for (Throwable cause : causes) {
 275                 if (cause != null) {
 276                     out.print("cause " + (num++) + ": ");
 277                     cause.printStackTrace(out);
 278                 }
 279             }
 280         }
 281     }
 282 
 283     /*
 284      * Overrides to the normal JUnit {@link Assert} routines that provide varargs style formatting
 285      * and produce an exception stack trace with the assertion frames trimmed out.
 286      */
 287 
 288     /**
 289      * Fails a test with the given message.
 290      *
 291      * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 292      *            okay)
 293      * @see AssertionError
 294      */
 295     public static void fail(String message, Object... objects) {
 296         AssertionError e;
 297         if (message == null) {
 298             e = new AssertionError();
 299         } else {
 300             e = new AssertionError(String.format(message, objects));
 301         }
 302         // Trim the assert frames from the stack trace
 303         StackTraceElement[] trace = e.getStackTrace();
 304         int start = 1; // Skip this frame
 305         String thisClassName = GraalTest.class.getName();
 306         while (start < trace.length && trace[start].getClassName().equals(thisClassName) && (trace[start].getMethodName().equals("assertTrue") || trace[start].getMethodName().equals("assertFalse"))) {
 307             start++;
 308         }
 309         e.setStackTrace(Arrays.copyOfRange(trace, start, trace.length));
 310         throw e;
 311     }
 312 
 313     /**
 314      * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
 315      * given message.
 316      *
 317      * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 318      *            okay)
 319      * @param condition condition to be checked
 320      */
 321     public static void assertTrue(String message, boolean condition) {
 322         assertTrue(condition, message);
 323     }
 324 
 325     /**
 326      * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} without a
 327      * message.
 328      *
 329      * @param condition condition to be checked
 330      */
 331     public static void assertTrue(boolean condition) {
 332         assertTrue(condition, null);
 333     }
 334 
 335     /**
 336      * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
 337      * given message.
 338      *
 339      * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 340      *            okay)
 341      * @param condition condition to be checked
 342      */
 343     public static void assertFalse(String message, boolean condition) {
 344         assertTrue(!condition, message);
 345     }
 346 
 347     /**
 348      * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} without a
 349      * message.
 350      *
 351      * @param condition condition to be checked
 352      */
 353     public static void assertFalse(boolean condition) {
 354         assertTrue(!condition, null);
 355     }
 356 
 357     /**
 358      * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
 359      * given message.
 360      *
 361      * @param condition condition to be checked
 362      * @param message the identifying message for the {@link AssertionError}
 363      * @param objects arguments to the format string
 364      */
 365     public static void assertTrue(boolean condition, String message, Object... objects) {
 366         if (!condition) {
 367             fail(message, objects);
 368         }
 369     }
 370 
 371     /**
 372      * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
 373      * given message produced by {@link String#format}.
 374      *
 375      * @param condition condition to be checked
 376      * @param message the identifying message for the {@link AssertionError}
 377      * @param objects arguments to the format string
 378      */
 379     public static void assertFalse(boolean condition, String message, Object... objects) {
 380         assertTrue(!condition, message, objects);
 381     }
 382 
 383     /**
 384      * Gets the {@link DebugHandlersFactory}s available for a {@link DebugContext}.
 385      */
 386     protected Collection<DebugHandlersFactory> getDebugHandlersFactories() {
 387         return Collections.emptyList();
 388     }
 389 
 390     /**
 391      * Gets a {@link DebugContext} object corresponding to {@code options}, creating a new one if
 392      * none currently exists. Debug contexts created by this method will have their
 393      * {@link DebugDumpHandler}s closed in {@link #afterTest()}.
 394      */
 395     protected DebugContext getDebugContext(OptionValues options) {
 396         return getDebugContext(options, null, null);
 397     }
 398 
 399     /**
 400      * Gets a {@link DebugContext} object corresponding to {@code options}, creating a new one if
 401      * none currently exists.Debug contexts created by this method will have their
 402      * {@link DebugDumpHandler}s closed in {@link #afterTest()}.
 403      * 
 404      * @param options currently active options
 405      * @param id identification of the compilation or {@code null}
 406      * @param method method to use for a proper description of the context or {@code null}
 407      * @return configured context for compilation
 408      */
 409     protected DebugContext getDebugContext(OptionValues options, String id, ResolvedJavaMethod method) {
 410         List<DebugContext> cached = cachedDebugs.get();
 411         if (cached == null) {
 412             cached = new ArrayList<>();
 413             cachedDebugs.set(cached);
 414         }
 415         for (DebugContext debug : cached) {
 416             if (debug.getOptions() == options) {
 417                 return debug;
 418             }
 419         }
 420         final DebugContext.Description descr;
 421         if (method == null) {
 422             descr = NO_DESCRIPTION;
 423         } else {
 424             descr = new DebugContext.Description(method, id == null ? method.getName() : id);
 425         }
 426         DebugContext debug = DebugContext.create(options, descr, NO_GLOBAL_METRIC_VALUES, DEFAULT_LOG_STREAM, getDebugHandlersFactories());
 427         cached.add(debug);
 428         return debug;
 429     }
 430 
 431     private final ThreadLocal<List<DebugContext>> cachedDebugs = new ThreadLocal<>();
 432 
 433     @After
 434     public void afterTest() {
 435         List<DebugContext> cached = cachedDebugs.get();
 436         if (cached != null) {
 437             for (DebugContext debug : cached) {
 438                 debug.closeDumpHandlers(true);
 439             }
 440         }
 441     }
 442 }
--- EOF ---