Mercurial > hg > graal-compiler

comparison graal/com.oracle.jvmci.test/src/com/oracle/jvmci/test/TestBase.java @ 21709:3c17c0c41a6b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
moved com.oracle.asm.**.test to JVMCI namespace (JBS:GRAAL-53)
author Doug Simon <doug.simon@oracle.com>
date Wed, 03 Jun 2015 18:33:23 +0200
parents graal/com.oracle.graal.test/src/com/oracle/graal/test/GraalTest.java@ea8d6fa333ab
children
comparison
equal deleted inserted replaced
21708:6df25b1418be 21709:3c17c0c41a6b
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 com.oracle.jvmci.test;
24
25 import java.io.*;
26 import java.lang.reflect.*;
27 import java.util.*;
28
29 import org.junit.*;
30 import org.junit.internal.*;
31
32 /**
33 * Base class that contains common utility methods and classes useful in unit tests.
34 */
35 public class TestBase {
36
37 protected Method getMethod(String methodName) {
38 return getMethod(getClass(), methodName);
39 }
40
41 protected Method getMethod(Class<?> clazz, String methodName) {
42 Method found = null;
43 for (Method m : clazz.getMethods()) {
44 if (m.getName().equals(methodName)) {
45 Assert.assertNull(found);
46 found = m;
47 }
48 }
49 if (found == null) {
50 /* Now look for non-public methods (but this does not look in superclasses). */
51 for (Method m : clazz.getDeclaredMethods()) {
52 if (m.getName().equals(methodName)) {
53 Assert.assertNull(found);
54 found = m;
55 }
56 }
57 }
58 if (found != null) {
59 return found;
60 } else {
61 throw new RuntimeException("method not found: " + methodName);
62 }
63 }
64
65 protected Method getMethod(Class<?> clazz, String methodName, Class<?>[] parameterTypes) {
66 try {
67 return clazz.getMethod(methodName, parameterTypes);
68 } catch (NoSuchMethodException | SecurityException e) {
69 throw new RuntimeException("method not found: " + methodName + "" + Arrays.toString(parameterTypes));
70 }
71 }
72
73 /**
74 * Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
75 * Does a deep copy equality comparison if {@code expected} is an array.
76 */
77 protected void assertDeepEquals(Object expected, Object actual) {
78 assertDeepEquals(null, expected, actual);
79 }
80
81 /**
82 * Compares two given objects for {@linkplain Assert#assertEquals(Object, Object) equality}.
83 * Does a deep copy equality comparison if {@code expected} is an array.
84 *
85 * @param message the identifying message for the {@link AssertionError}
86 */
87 protected void assertDeepEquals(String message, Object expected, Object actual) {
88 if (ulpsDelta() > 0) {
89 assertDeepEquals(message, expected, actual, ulpsDelta());
90 } else {
91 assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
92 }
93 }
94
95 /**
96 * Compares two given values for equality, doing a recursive test if both values are arrays of
97 * the same type.
98 *
99 * @param message the identifying message for the {@link AssertionError}
100 * @param delta the maximum delta between two doubles or floats for which both numbers are still
101 * considered equal.
102 */
103 protected void assertDeepEquals(String message, Object expected, Object actual, double delta) {
104 if (expected != null && actual != null) {
105 Class<?> expectedClass = expected.getClass();
106 Class<?> actualClass = actual.getClass();
107 if (expectedClass.isArray()) {
108 Assert.assertTrue(message, expected != null);
109 Assert.assertTrue(message, actual != null);
110 Assert.assertEquals(message, expectedClass, actual.getClass());
111 if (expected instanceof int[]) {
112 Assert.assertArrayEquals(message, (int[]) expected, (int[]) actual);
113 } else if (expected instanceof byte[]) {
114 Assert.assertArrayEquals(message, (byte[]) expected, (byte[]) actual);
115 } else if (expected instanceof char[]) {
116 Assert.assertArrayEquals(message, (char[]) expected, (char[]) actual);
117 } else if (expected instanceof short[]) {
118 Assert.assertArrayEquals(message, (short[]) expected, (short[]) actual);
119 } else if (expected instanceof float[]) {
120 Assert.assertArrayEquals(message, (float[]) expected, (float[]) actual, (float) delta);
121 } else if (expected instanceof long[]) {
122 Assert.assertArrayEquals(message, (long[]) expected, (long[]) actual);
123 } else if (expected instanceof double[]) {
124 Assert.assertArrayEquals(message, (double[]) expected, (double[]) actual, delta);
125 } else if (expected instanceof boolean[]) {
126 new ExactComparisonCriteria().arrayEquals(message, expected, actual);
127 } else if (expected instanceof Object[]) {
128 new ComparisonCriteria() {
129 @Override
130 protected void assertElementsEqual(Object e, Object a) {
131 assertDeepEquals(message, e, a, delta);
132 }
133 }.arrayEquals(message, expected, actual);
134 } else {
135 Assert.fail((message == null ? "" : message) + "non-array value encountered: " + expected);
136 }
137 } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
138 Assert.assertEquals((double) expected, (double) actual, delta);
139 } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
140 Assert.assertEquals((float) expected, (float) actual, delta);
141 } else {
142 Assert.assertEquals(message, expected, actual);
143 }
144 } else {
145 Assert.assertEquals(message, expected, actual);
146 }
147 }
148
149 /**
150 * Compares two given values for equality, doing a recursive test if both values are arrays of
151 * the same type. Uses {@linkplain StrictMath#ulp(float) ULP}s for comparison of floats.
152 *
153 * @param message the identifying message for the {@link AssertionError}
154 * @param ulpsDelta the maximum allowed ulps difference between two doubles or floats for which
155 * both numbers are still considered equal.
156 */
157 protected void assertDeepEquals(String message, Object expected, Object actual, int ulpsDelta) {
158 ComparisonCriteria doubleUlpsDeltaCriteria = new ComparisonCriteria() {
159 @Override
160 protected void assertElementsEqual(Object e, Object a) {
161 assertTrue(message, e instanceof Double && a instanceof Double);
162 // determine acceptable error based on whether it is a normal number or a NaN/Inf
163 double de = (Double) e;
164 double epsilon = (!Double.isNaN(de) && Double.isFinite(de) ? ulpsDelta * Math.ulp(de) : 0);
165 Assert.assertEquals(message, (Double) e, (Double) a, epsilon);
166 }
167 };
168
169 ComparisonCriteria floatUlpsDeltaCriteria = new ComparisonCriteria() {
170 @Override
171 protected void assertElementsEqual(Object e, Object a) {
172 assertTrue(message, e instanceof Float && a instanceof Float);
173 // determine acceptable error based on whether it is a normal number or a NaN/Inf
174 float fe = (Float) e;
175 float epsilon = (!Float.isNaN(fe) && Float.isFinite(fe) ? ulpsDelta * Math.ulp(fe) : 0);
176 Assert.assertEquals(message, (Float) e, (Float) a, epsilon);
177 }
178 };
179
180 if (expected != null && actual != null) {
181 Class<?> expectedClass = expected.getClass();
182 Class<?> actualClass = actual.getClass();
183 if (expectedClass.isArray()) {
184 Assert.assertEquals(message, expectedClass, actualClass);
185 if (expected instanceof double[] || expected instanceof Object[]) {
186 doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
187 return;
188 } else if (expected instanceof float[] || expected instanceof Object[]) {
189 floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
190 return;
191 }
192 } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
193 doubleUlpsDeltaCriteria.arrayEquals(message, expected, actual);
194 return;
195 } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
196 floatUlpsDeltaCriteria.arrayEquals(message, expected, actual);
197 return;
198 }
199 }
200 // anything else just use the non-ulps version
201 assertDeepEquals(message, expected, actual, equalFloatsOrDoublesDelta());
202 }
203
204 /**
205 * Gets the value used by {@link #assertDeepEquals(Object, Object)} and
206 * {@link #assertDeepEquals(String, Object, Object)} for the maximum delta between two doubles
207 * or floats for which both numbers are still considered equal.
208 */
209 protected double equalFloatsOrDoublesDelta() {
210 return 0.0D;
211 }
212
213 // unless overridden ulpsDelta is not used
214 protected int ulpsDelta() {
215 return 0;
216 }
217
218 @SuppressWarnings("serial")
219 public static class MultiCauseAssertionError extends AssertionError {
220
221 private Throwable[] causes;
222
223 public MultiCauseAssertionError(String message, Throwable... causes) {
224 super(message);
225 this.causes = causes;
226 }
227
228 @Override
229 public void printStackTrace(PrintStream out) {
230 super.printStackTrace(out);
231 int num = 0;
232 for (Throwable cause : causes) {
233 if (cause != null) {
234 out.print("cause " + (num++));
235 cause.printStackTrace(out);
236 }
237 }
238 }
239
240 @Override
241 public void printStackTrace(PrintWriter out) {
242 super.printStackTrace(out);
243 int num = 0;
244 for (Throwable cause : causes) {
245 if (cause != null) {
246 out.print("cause " + (num++) + ": ");
247 cause.printStackTrace(out);
248 }
249 }
250 }
251 }
252
253 /*
254 * Overrides to the normal JUnit {@link Assert} routines that provide varargs style formatting
255 * and produce an exception stack trace with the assertion frames trimmed out.
256 */
257
258 /**
259 * Fails a test with the given message.
260 *
261 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
262 * okay)
263 * @see AssertionError
264 */
265 public static void fail(String message, Object... objects) {
266 AssertionError e;
267 if (message == null) {
268 e = new AssertionError();
269 } else {
270 e = new AssertionError(String.format(message, objects));
271 }
272 // Trim the assert frames from the stack trace
273 StackTraceElement[] trace = e.getStackTrace();
274 int start = 1; // Skip this frame
275 String thisClassName = TestBase.class.getName();
276 while (start < trace.length && trace[start].getClassName().equals(thisClassName) && (trace[start].getMethodName().equals("assertTrue") || trace[start].getMethodName().equals("assertFalse"))) {
277 start++;
278 }
279 e.setStackTrace(Arrays.copyOfRange(trace, start, trace.length));
280 throw e;
281 }
282
283 /**
284 * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
285 * given message.
286 *
287 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
288 * okay)
289 * @param condition condition to be checked
290 */
291 public static void assertTrue(String message, boolean condition) {
292 assertTrue(condition, message);
293 }
294
295 /**
296 * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} without a
297 * message.
298 *
299 * @param condition condition to be checked
300 */
301 public static void assertTrue(boolean condition) {
302 assertTrue(condition, null);
303 }
304
305 /**
306 * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
307 * given message.
308 *
309 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
310 * okay)
311 * @param condition condition to be checked
312 */
313 public static void assertFalse(String message, boolean condition) {
314 assertTrue(!condition, message);
315 }
316
317 /**
318 * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} without a
319 * message.
320 *
321 * @param condition condition to be checked
322 */
323 public static void assertFalse(boolean condition) {
324 assertTrue(!condition, null);
325 }
326
327 /**
328 * Asserts that a condition is true. If it isn't it throws an {@link AssertionError} with the
329 * given message.
330 *
331 * @param condition condition to be checked
332 * @param message the identifying message for the {@link AssertionError}
333 * @param objects arguments to the format string
334 */
335 public static void assertTrue(boolean condition, String message, Object... objects) {
336 if (!condition) {
337 fail(message, objects);
338 }
339 }
340
341 /**
342 * Asserts that a condition is false. If it isn't it throws an {@link AssertionError} with the
343 * given message produced by {@link String#format}.
344 *
345 * @param condition condition to be checked
346 * @param message the identifying message for the {@link AssertionError}
347 * @param objects arguments to the format string
348 */
349 public static void assertFalse(boolean condition, String message, Object... objects) {
350 assertTrue(!condition, message, objects);
351 }
352
353 }