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
24 /*
25 * @test
26 * @bug 8014076 8025067
27 * @summary unit test for Arrays.ParallelPrefix().
28 * @modules java.management jdk.management
29 * @run junit/othervm -Xms256m -Xmx1024m ParallelPrefix
30 */
31
32 import java.lang.management.ManagementFactory;
33 import java.util.Arrays;
34 import java.util.function.BinaryOperator;
35 import java.util.function.DoubleBinaryOperator;
36 import java.util.function.Function;
37 import java.util.function.IntBinaryOperator;
38 import java.util.function.LongBinaryOperator;
39 import java.util.stream.IntStream;
40 import java.util.stream.LongStream;
41 import com.sun.management.OperatingSystemMXBean;
42
43 import static org.junit.jupiter.api.Assertions.*;
44 import org.junit.jupiter.api.BeforeAll;
45 import org.junit.jupiter.api.Test;
46 import org.junit.jupiter.api.TestInstance;
47 import org.junit.jupiter.api.function.Executable;
48 import org.junit.jupiter.params.ParameterizedTest;
49 import org.junit.jupiter.params.provider.MethodSource;
50
51 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
52 public class ParallelPrefix {
53 //Array size less than MIN_PARTITION
54 private static final int SMALL_ARRAY_SIZE = 1 << 3;
55
56 //Array size equals MIN_PARTITION
57 private static final int THRESHOLD_ARRAY_SIZE = 1 << 4;
58
59 //Array size greater than MIN_PARTITION
60 private static final int MEDIUM_ARRAY_SIZE = 1 << 8;
61
62 //Array size much greater than MIN_PARTITION
63 private static final int LARGE_ARRAY_SIZE = 1 << 14;
64
65 private static int[] arraySizeCollection;
66
67 @BeforeAll
68 public static void setup() {
69 java.lang.management.OperatingSystemMXBean bean =
70 ManagementFactory.getOperatingSystemMXBean();
71 if (bean instanceof OperatingSystemMXBean) {
72 OperatingSystemMXBean os = (OperatingSystemMXBean)bean;
73 long physicalMemorySize = os.getTotalPhysicalMemorySize() / (1024 * 1024);
74 System.out.println("System memory size: " + physicalMemorySize + "M");
75 // when we can get system memory size, and it's larger than 2G,
76 // then we enable large array size test below,
77 // else disable large array size test below.
78 if (physicalMemorySize > (2 * 1024)) {
79 arraySizeCollection = new int[]{
80 SMALL_ARRAY_SIZE,
81 THRESHOLD_ARRAY_SIZE,
82 MEDIUM_ARRAY_SIZE,
83 LARGE_ARRAY_SIZE
84 };
85 System.out.println("System memory is large enough, add large array size test");
86 return;
125 }
126
127 private static <T, OPS> Object[][] genericData(Function<Integer, T> generateFunc, OPS[] ops) {
128 //test arrays which size is equals n-1, n, n+1, test random data
129 Object[][] data = new Object[arraySizeCollection.length * 3 * ops.length][4];
130 for(int n = 0; n < arraySizeCollection.length; n++ ) {
131 for(int testValue = -1 ; testValue <= 1; testValue++) {
132 int array_size = arraySizeCollection[n] + testValue;
133 for(int opsN = 0; opsN < ops.length; opsN++) {
134 int index = n * 3 * ops.length + (testValue + 1) * ops.length + opsN;
135 data[index][0] = generateFunc.apply(array_size);
136 data[index][1] = array_size / 3;
137 data[index][2] = 2 * array_size / 3;
138 data[index][3] = ops[opsN];
139 }
140 }
141 }
142 return data;
143 }
144
145 @ParameterizedTest
146 @MethodSource("intSet")
147 public void testParallelPrefixForInt(int[] data, int fromIndex, int toIndex, IntBinaryOperator op) {
148 int[] sequentialResult = data.clone();
149 for (int index = fromIndex + 1; index < toIndex; index++) {
150 sequentialResult[index ] = op.applyAsInt(sequentialResult[index - 1], sequentialResult[index]);
151 }
152
153 int[] parallelResult = data.clone();
154 Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
155 assertArraysEqual(sequentialResult, parallelResult);
156
157 int[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
158 Arrays.parallelPrefix(parallelRangeResult, op);
159 assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
160 }
161
162 @ParameterizedTest
163 @MethodSource("longSet")
164 public void testParallelPrefixForLong(long[] data, int fromIndex, int toIndex, LongBinaryOperator op) {
193 assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
194 }
195
196 @ParameterizedTest
197 @MethodSource("stringSet")
198 public void testParallelPrefixForStringr(String[] data , int fromIndex, int toIndex, BinaryOperator<String> op) {
199 String[] sequentialResult = data.clone();
200 for (int index = fromIndex + 1; index < toIndex; index++) {
201 sequentialResult[index ] = op.apply(sequentialResult[index - 1], sequentialResult[index]);
202 }
203
204 String[] parallelResult = data.clone();
205 Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
206 assertArraysEqual(sequentialResult, parallelResult);
207
208 String[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
209 Arrays.parallelPrefix(parallelRangeResult, op);
210 assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
211 }
212
213 @Test
214 public void testNPEs() {
215 // null array
216 assertThrowsNPE(() -> Arrays.parallelPrefix((int[]) null, Integer::max));
217 assertThrowsNPE(() -> Arrays.parallelPrefix((long []) null, Long::max));
218 assertThrowsNPE(() -> Arrays.parallelPrefix((double []) null, Double::max));
219 assertThrowsNPE(() -> Arrays.parallelPrefix((String []) null, String::concat));
220
221 // null array w/ range
222 assertThrowsNPE(() -> Arrays.parallelPrefix((int[]) null, 0, 0, Integer::max));
223 assertThrowsNPE(() -> Arrays.parallelPrefix((long []) null, 0, 0, Long::max));
224 assertThrowsNPE(() -> Arrays.parallelPrefix((double []) null, 0, 0, Double::max));
225 assertThrowsNPE(() -> Arrays.parallelPrefix((String []) null, 0, 0, String::concat));
226
227 // null op
228 assertThrowsNPE(() -> Arrays.parallelPrefix(new int[] {}, null));
229 assertThrowsNPE(() -> Arrays.parallelPrefix(new long[] {}, null));
230 assertThrowsNPE(() -> Arrays.parallelPrefix(new double[] {}, null));
231 assertThrowsNPE(() -> Arrays.parallelPrefix(new String[] {}, null));
232
233 // null op w/ range
234 assertThrowsNPE(() -> Arrays.parallelPrefix(new int[] {}, 0, 0, null));
235 assertThrowsNPE(() -> Arrays.parallelPrefix(new long[] {}, 0, 0, null));
236 assertThrowsNPE(() -> Arrays.parallelPrefix(new double[] {}, 0, 0, null));
237 assertThrowsNPE(() -> Arrays.parallelPrefix(new String[] {}, 0, 0, null));
238 }
239
240 @Test
241 public void testIAEs() {
242 assertThrowsIAE(() -> Arrays.parallelPrefix(new int[] {}, 1, 0, Integer::max));
243 assertThrowsIAE(() -> Arrays.parallelPrefix(new long[] {}, 1, 0, Long::max));
244 assertThrowsIAE(() -> Arrays.parallelPrefix(new double[] {}, 1, 0, Double::max));
245 assertThrowsIAE(() -> Arrays.parallelPrefix(new String[] {}, 1, 0, String::concat));
246 }
247
248 @Test
249 public void testAIOOBEs() {
250 // bad "fromIndex"
251 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new int[] {}, -1, 0, Integer::max));
252 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new long[] {}, -1, 0, Long::max));
253 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new double[] {}, -1, 0, Double::max));
254 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new String[] {}, -1, 0, String::concat));
255
256 // bad "toIndex"
257 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new int[] {}, 0, 1, Integer::max));
258 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new long[] {}, 0, 1, Long::max));
259 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new double[] {}, 0, 1, Double::max));
260 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new String[] {}, 0, 1, String::concat));
261 }
262
263 // "library" code
264
265 private void assertThrowsNPE(Executable r) {
266 assertThrows(NullPointerException.class, r);
267 }
268
269 private void assertThrowsIAE(Executable r) {
270 assertThrows(IllegalArgumentException.class, r);
271 }
272
273 private void assertThrowsAIOOB(Executable r) {
274 assertThrows(ArrayIndexOutOfBoundsException.class, r);
275 }
276
277 static void assertArraysEqual(int[] expected, int[] actual) {
278 try {
279 assertArrayEquals(expected, actual, "");
280 } catch (AssertionError x) {
292 }
293 }
294
295 static void assertArraysEqual(double[] expected, double[] actual) {
296 try {
297 assertArrayEquals(expected, actual, "");
298 } catch (AssertionError x) {
299 throw new AssertionError(String.format("Expected:%s, actual:%s",
300 Arrays.toString(expected), Arrays.toString(actual)), x);
301 }
302 }
303
304 static void assertArraysEqual(String[] expected, String[] actual) {
305 try {
306 assertArrayEquals(expected, actual, "");
307 } catch (AssertionError x) {
308 throw new AssertionError(String.format("Expected:%s, actual:%s",
309 Arrays.toString(expected), Arrays.toString(actual)), x);
310 }
311 }
312 }
313
|
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
24 /*
25 * @test
26 * @bug 8014076 8025067
27 * @summary unit test for Arrays.ParallelPrefix().
28 * @modules java.management jdk.management
29 * @library /test/lib
30 * @run junit/othervm -Xms256m -Xmx1024m ParallelPrefix
31 */
32
33 import java.lang.management.ManagementFactory;
34 import java.util.Arrays;
35 import java.util.function.BinaryOperator;
36 import java.util.function.DoubleBinaryOperator;
37 import java.util.function.Function;
38 import java.util.function.IntBinaryOperator;
39 import java.util.function.LongBinaryOperator;
40 import java.util.stream.IntStream;
41 import java.util.stream.LongStream;
42 import com.sun.management.OperatingSystemMXBean;
43
44 import jdk.test.lib.valueclass.AsValueClass;
45
46 import static org.junit.jupiter.api.Assertions.*;
47 import org.junit.jupiter.api.BeforeAll;
48 import org.junit.jupiter.api.Test;
49 import org.junit.jupiter.api.TestInstance;
50 import org.junit.jupiter.api.function.Executable;
51 import org.junit.jupiter.params.ParameterizedTest;
52 import org.junit.jupiter.params.provider.MethodSource;
53
54 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
55 public class ParallelPrefix {
56 //Array size less than MIN_PARTITION
57 private static final int SMALL_ARRAY_SIZE = 1 << 3;
58
59 //Array size equals MIN_PARTITION
60 private static final int THRESHOLD_ARRAY_SIZE = 1 << 4;
61
62 //Array size greater than MIN_PARTITION
63 private static final int MEDIUM_ARRAY_SIZE = 1 << 8;
64
65 //Array size much greater than MIN_PARTITION
66 private static final int LARGE_ARRAY_SIZE = 1 << 14;
67
68 private static int[] arraySizeCollection;
69
70 @AsValueClass
71 record VInt(int value) {}
72
73 @BeforeAll
74 public static void setup() {
75 java.lang.management.OperatingSystemMXBean bean =
76 ManagementFactory.getOperatingSystemMXBean();
77 if (bean instanceof OperatingSystemMXBean) {
78 OperatingSystemMXBean os = (OperatingSystemMXBean)bean;
79 long physicalMemorySize = os.getTotalPhysicalMemorySize() / (1024 * 1024);
80 System.out.println("System memory size: " + physicalMemorySize + "M");
81 // when we can get system memory size, and it's larger than 2G,
82 // then we enable large array size test below,
83 // else disable large array size test below.
84 if (physicalMemorySize > (2 * 1024)) {
85 arraySizeCollection = new int[]{
86 SMALL_ARRAY_SIZE,
87 THRESHOLD_ARRAY_SIZE,
88 MEDIUM_ARRAY_SIZE,
89 LARGE_ARRAY_SIZE
90 };
91 System.out.println("System memory is large enough, add large array size test");
92 return;
131 }
132
133 private static <T, OPS> Object[][] genericData(Function<Integer, T> generateFunc, OPS[] ops) {
134 //test arrays which size is equals n-1, n, n+1, test random data
135 Object[][] data = new Object[arraySizeCollection.length * 3 * ops.length][4];
136 for(int n = 0; n < arraySizeCollection.length; n++ ) {
137 for(int testValue = -1 ; testValue <= 1; testValue++) {
138 int array_size = arraySizeCollection[n] + testValue;
139 for(int opsN = 0; opsN < ops.length; opsN++) {
140 int index = n * 3 * ops.length + (testValue + 1) * ops.length + opsN;
141 data[index][0] = generateFunc.apply(array_size);
142 data[index][1] = array_size / 3;
143 data[index][2] = 2 * array_size / 3;
144 data[index][3] = ops[opsN];
145 }
146 }
147 }
148 return data;
149 }
150
151 public static Object[][] valueSet() {
152 Function<Integer, VInt[]> vIntFunc = size ->
153 IntStream.range(0, size).mapToObj(VInt::new).toArray(VInt[]::new);
154 BinaryOperator<VInt> sumOp = (a, b) -> new VInt(a.value() + b.value());
155 BinaryOperator<VInt> minOp = (a, b) -> a.value() <= b.value() ? a : b;
156 return genericData(vIntFunc,
157 (BinaryOperator<VInt>[]) new BinaryOperator[]{sumOp, minOp});
158 }
159
160 @ParameterizedTest
161 @MethodSource("intSet")
162 public void testParallelPrefixForInt(int[] data, int fromIndex, int toIndex, IntBinaryOperator op) {
163 int[] sequentialResult = data.clone();
164 for (int index = fromIndex + 1; index < toIndex; index++) {
165 sequentialResult[index ] = op.applyAsInt(sequentialResult[index - 1], sequentialResult[index]);
166 }
167
168 int[] parallelResult = data.clone();
169 Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
170 assertArraysEqual(sequentialResult, parallelResult);
171
172 int[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
173 Arrays.parallelPrefix(parallelRangeResult, op);
174 assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
175 }
176
177 @ParameterizedTest
178 @MethodSource("longSet")
179 public void testParallelPrefixForLong(long[] data, int fromIndex, int toIndex, LongBinaryOperator op) {
208 assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
209 }
210
211 @ParameterizedTest
212 @MethodSource("stringSet")
213 public void testParallelPrefixForStringr(String[] data , int fromIndex, int toIndex, BinaryOperator<String> op) {
214 String[] sequentialResult = data.clone();
215 for (int index = fromIndex + 1; index < toIndex; index++) {
216 sequentialResult[index ] = op.apply(sequentialResult[index - 1], sequentialResult[index]);
217 }
218
219 String[] parallelResult = data.clone();
220 Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
221 assertArraysEqual(sequentialResult, parallelResult);
222
223 String[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
224 Arrays.parallelPrefix(parallelRangeResult, op);
225 assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
226 }
227
228 @ParameterizedTest
229 @MethodSource("valueSet")
230 public void testParallelPrefixForValue(VInt[] data, int fromIndex, int toIndex, BinaryOperator<VInt> op) {
231 VInt[] sequentialResult = data.clone();
232 for (int index = fromIndex + 1; index < toIndex; index++) {
233 sequentialResult[index] = op.apply(sequentialResult[index - 1], sequentialResult[index]);
234 }
235
236 VInt[] parallelResult = data.clone();
237 Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
238 assertArraysEqual(parallelResult, sequentialResult);
239
240 VInt[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
241 Arrays.parallelPrefix(parallelRangeResult, op);
242 assertArraysEqual(parallelRangeResult, Arrays.copyOfRange(sequentialResult, fromIndex, toIndex));
243 }
244
245 @Test
246 public void testNPEs() {
247 // null array
248 assertThrowsNPE(() -> Arrays.parallelPrefix((int[]) null, Integer::max));
249 assertThrowsNPE(() -> Arrays.parallelPrefix((long []) null, Long::max));
250 assertThrowsNPE(() -> Arrays.parallelPrefix((double []) null, Double::max));
251 assertThrowsNPE(() -> Arrays.parallelPrefix((String []) null, String::concat));
252 assertThrowsNPE(() -> Arrays.parallelPrefix((VInt[]) null, (a, b) -> new VInt(a.value() + b.value())));
253
254 // null array w/ range
255 assertThrowsNPE(() -> Arrays.parallelPrefix((int[]) null, 0, 0, Integer::max));
256 assertThrowsNPE(() -> Arrays.parallelPrefix((long []) null, 0, 0, Long::max));
257 assertThrowsNPE(() -> Arrays.parallelPrefix((double []) null, 0, 0, Double::max));
258 assertThrowsNPE(() -> Arrays.parallelPrefix((String []) null, 0, 0, String::concat));
259 assertThrowsNPE(() -> Arrays.parallelPrefix((VInt[]) null, 0, 0, (a, b) -> new VInt(a.value() + b.value())));
260
261 // null op
262 assertThrowsNPE(() -> Arrays.parallelPrefix(new int[] {}, null));
263 assertThrowsNPE(() -> Arrays.parallelPrefix(new long[] {}, null));
264 assertThrowsNPE(() -> Arrays.parallelPrefix(new double[] {}, null));
265 assertThrowsNPE(() -> Arrays.parallelPrefix(new String[] {}, null));
266 assertThrowsNPE(() -> Arrays.parallelPrefix(new VInt[] {}, (BinaryOperator<VInt>) null));
267
268 // null op w/ range
269 assertThrowsNPE(() -> Arrays.parallelPrefix(new int[] {}, 0, 0, null));
270 assertThrowsNPE(() -> Arrays.parallelPrefix(new long[] {}, 0, 0, null));
271 assertThrowsNPE(() -> Arrays.parallelPrefix(new double[] {}, 0, 0, null));
272 assertThrowsNPE(() -> Arrays.parallelPrefix(new String[] {}, 0, 0, null));
273 assertThrowsNPE(() -> Arrays.parallelPrefix(new VInt[] {}, 0, 0, (BinaryOperator<VInt>) null));
274 }
275
276 @Test
277 public void testIAEs() {
278 assertThrowsIAE(() -> Arrays.parallelPrefix(new int[] {}, 1, 0, Integer::max));
279 assertThrowsIAE(() -> Arrays.parallelPrefix(new long[] {}, 1, 0, Long::max));
280 assertThrowsIAE(() -> Arrays.parallelPrefix(new double[] {}, 1, 0, Double::max));
281 assertThrowsIAE(() -> Arrays.parallelPrefix(new String[] {}, 1, 0, String::concat));
282 assertThrowsIAE(() -> Arrays.parallelPrefix(new VInt[] {}, 1, 0, (a, b) -> new VInt(a.value() + b.value())));
283 }
284
285 @Test
286 public void testAIOOBEs() {
287 // bad "fromIndex"
288 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new int[] {}, -1, 0, Integer::max));
289 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new long[] {}, -1, 0, Long::max));
290 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new double[] {}, -1, 0, Double::max));
291 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new String[] {}, -1, 0, String::concat));
292 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new VInt[] {}, -1, 0, (a, b) -> new VInt(a.value() + b.value())));
293
294 // bad "toIndex"
295 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new int[] {}, 0, 1, Integer::max));
296 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new long[] {}, 0, 1, Long::max));
297 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new double[] {}, 0, 1, Double::max));
298 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new String[] {}, 0, 1, String::concat));
299 assertThrowsAIOOB(() -> Arrays.parallelPrefix(new VInt[] {}, 0, 1, (a, b) -> new VInt(a.value() + b.value())));
300 }
301
302 // "library" code
303
304 private void assertThrowsNPE(Executable r) {
305 assertThrows(NullPointerException.class, r);
306 }
307
308 private void assertThrowsIAE(Executable r) {
309 assertThrows(IllegalArgumentException.class, r);
310 }
311
312 private void assertThrowsAIOOB(Executable r) {
313 assertThrows(ArrayIndexOutOfBoundsException.class, r);
314 }
315
316 static void assertArraysEqual(int[] expected, int[] actual) {
317 try {
318 assertArrayEquals(expected, actual, "");
319 } catch (AssertionError x) {
331 }
332 }
333
334 static void assertArraysEqual(double[] expected, double[] actual) {
335 try {
336 assertArrayEquals(expected, actual, "");
337 } catch (AssertionError x) {
338 throw new AssertionError(String.format("Expected:%s, actual:%s",
339 Arrays.toString(expected), Arrays.toString(actual)), x);
340 }
341 }
342
343 static void assertArraysEqual(String[] expected, String[] actual) {
344 try {
345 assertArrayEquals(expected, actual, "");
346 } catch (AssertionError x) {
347 throw new AssertionError(String.format("Expected:%s, actual:%s",
348 Arrays.toString(expected), Arrays.toString(actual)), x);
349 }
350 }
351
352 static void assertArraysEqual(VInt[] actual, VInt[] expected) {
353 try {
354 assertArrayEquals(actual, expected, "");
355 } catch (AssertionError x) {
356 throw new AssertionError(String.format("Expected:%s, actual:%s",
357 Arrays.toString(expected), Arrays.toString(actual)), x);
358 }
359 }
360 }
361
|