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