1 /*
2 * Copyright (c) 2012, 2019, 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
24 import java.math.BigInteger;
25
26 /**
27 * @test Test for Math.*Exact integer and long methods.
28 * @bug 6708398
29 * @summary Basic tests for Math exact arithmetic operations.
30 *
31 * @author Roger Riggs
32 */
33 public class ExactArithTests {
34
35 /**
36 * The count of test errors.
37 */
38 private static int errors = 0;
39
40 /**
41 * @param args the command line arguments
42 */
43 public static void main(String[] args) {
44 testIntegerExact();
45 testLongExact();
46 testLongIntExact();
47
48 if (errors > 0) {
49 throw new RuntimeException(errors + " errors found in ExactArithTests.");
50 }
51 }
52
53 static void fail(String message) {
54 errors++;
55 System.err.println(message);
56 }
57
58 /**
59 * Test Math.addExact, multiplyExact, subtractExact, incrementExact,
60 * decrementExact, negateExact methods with {@code int} arguments.
61 */
62 static void testIntegerExact() {
63 testIntegerExact(0, 0);
64 testIntegerExact(1, 1);
65 testIntegerExact(1, -1);
66 testIntegerExact(-1, 1);
67 testIntegerExact(1000, 2000);
68
69 testIntegerExact(Integer.MIN_VALUE, Integer.MIN_VALUE);
70 testIntegerExact(Integer.MAX_VALUE, Integer.MAX_VALUE);
71 testIntegerExact(Integer.MIN_VALUE, 1);
72 testIntegerExact(Integer.MAX_VALUE, 1);
73 testIntegerExact(Integer.MIN_VALUE, 2);
74 testIntegerExact(Integer.MAX_VALUE, 2);
75 testIntegerExact(Integer.MIN_VALUE, -1);
76 testIntegerExact(Integer.MAX_VALUE, -1);
77 testIntegerExact(Integer.MIN_VALUE, -2);
78 testIntegerExact(Integer.MAX_VALUE, -2);
79 }
80
81 /**
82 * Test exact arithmetic by comparing with the same operations using long
83 * and checking that the result is the same as the integer truncation.
84 * Errors are reported with {@link fail}.
85 *
86 * @param x first parameter
87 * @param y second parameter
88 */
89 static void testIntegerExact(int x, int y) {
90 try {
91 // Test addExact
92 int sum = Math.addExact(x, y);
93 long sum2 = (long) x + (long) y;
94 if ((int) sum2 != sum2) {
95 fail("FAIL: int Math.addExact(" + x + " + " + y + ") = " + sum + "; expected Arithmetic exception");
96 } else if (sum != sum2) {
97 fail("FAIL: long Math.addExact(" + x + " + " + y + ") = " + sum + "; expected: " + sum2);
98 }
99 } catch (ArithmeticException ex) {
100 long sum2 = (long) x + (long) y;
101 if ((int) sum2 == sum2) {
102 fail("FAIL: int Math.addExact(" + x + " + " + y + ")" + "; Unexpected exception: " + ex);
103 }
104 }
105
106 try {
107 // Test subtractExact
108 int diff = Math.subtractExact(x, y);
109 long diff2 = (long) x - (long) y;
110 if ((int) diff2 != diff2) {
111 fail("FAIL: int Math.subtractExact(" + x + " - " + y + ") = " + diff + "; expected: " + diff2);
112 }
113
114 } catch (ArithmeticException ex) {
115 long diff2 = (long) x - (long) y;
116 if ((int) diff2 == diff2) {
117 fail("FAIL: int Math.subtractExact(" + x + " - " + y + ")" + "; Unexpected exception: " + ex);
118 }
119 }
120
121 try {
122 // Test multiplyExact
123 int product = Math.multiplyExact(x, y);
124 long m2 = (long) x * (long) y;
125 if ((int) m2 != m2) {
126 fail("FAIL: int Math.multiplyExact(" + x + " * " + y + ") = " + product + "; expected: " + m2);
127 }
128 } catch (ArithmeticException ex) {
129 long m2 = (long) x * (long) y;
130 if ((int) m2 == m2) {
131 fail("FAIL: int Math.multiplyExact(" + x + " * " + y + ")" + "; Unexpected exception: " + ex);
132 }
133 }
134
135 try {
136 // Test incrementExact
137 int inc = Math.incrementExact(x);
138 long inc2 = (long) x + 1L;
139 if ((int) inc2 != inc2) {
140 fail("FAIL: int Math.incrementExact(" + x + ") = " + inc + "; expected Arithmetic exception");
141 } else if (inc != inc2) {
142 fail("FAIL: long Math.incrementExact(" + x + ") = " + inc + "; expected: " + inc2);
143 }
144 } catch (ArithmeticException ex) {
145 long inc2 = (long) x + 1L;
146 if ((int) inc2 == inc2) {
147 fail("FAIL: int Math.incrementExact(" + x + ")" + "; Unexpected exception: " + ex);
148 }
149 }
150
151 try {
152 // Test decrementExact
153 int dec = Math.decrementExact(x);
154 long dec2 = (long) x - 1L;
155 if ((int) dec2 != dec2) {
156 fail("FAIL: int Math.decrementExact(" + x + ") = " + dec + "; expected Arithmetic exception");
157 } else if (dec != dec2) {
158 fail("FAIL: long Math.decrementExact(" + x + ") = " + dec + "; expected: " + dec2);
159 }
160 } catch (ArithmeticException ex) {
161 long dec2 = (long) x - 1L;
162 if ((int) dec2 == dec2) {
163 fail("FAIL: int Math.decrementExact(" + x + ")" + "; Unexpected exception: " + ex);
164 }
165 }
166
167 try {
168 // Test negateExact
169 int neg = Math.negateExact(x);
170 long neg2 = -((long)x) ;
171 if ((int) neg2 != neg2) {
172 fail("FAIL: int Math.negateExact(" + x + ") = " + neg + "; expected Arithmetic exception");
173 } else if (neg != neg2) {
174 fail("FAIL: long Math.negateExact(" + x + ") = " + neg + "; expected: " + neg2);
175 }
176 } catch (ArithmeticException ex) {
177 long neg2 = (long) x - 1L;
178 if ((int) neg2 == neg2) {
179 fail("FAIL: int Math.negateExact(" + x + ")" + "; Unexpected exception: " + ex);
180 }
181 }
182 }
183
184 /**
185 * Test Math.addExact, multiplyExact, subtractExact, incrementExact,
186 * decrementExact, negateExact, toIntExact methods with {@code long} arguments.
187 */
188 static void testLongExact() {
189 testLongExactTwice(0, 0);
190 testLongExactTwice(1, 1);
191 testLongExactTwice(1, -1);
192 testLongExactTwice(1000, 2000);
193
194 testLongExactTwice(Long.MIN_VALUE, Long.MIN_VALUE);
195 testLongExactTwice(Long.MAX_VALUE, Long.MAX_VALUE);
196 testLongExactTwice(Long.MIN_VALUE, 1);
197 testLongExactTwice(Long.MAX_VALUE, 1);
198 testLongExactTwice(Long.MIN_VALUE, 2);
199 testLongExactTwice(Long.MAX_VALUE, 2);
200 testLongExactTwice(Long.MIN_VALUE, -1);
201 testLongExactTwice(Long.MAX_VALUE, -1);
202 testLongExactTwice(Long.MIN_VALUE, -2);
203 testLongExactTwice(Long.MAX_VALUE, -2);
204 testLongExactTwice(Long.MIN_VALUE/2, 2);
205 testLongExactTwice(Long.MAX_VALUE, 2);
206 testLongExactTwice(Integer.MAX_VALUE, Integer.MAX_VALUE);
207 testLongExactTwice(Integer.MAX_VALUE, -Integer.MAX_VALUE);
208 testLongExactTwice(Integer.MAX_VALUE+1, Integer.MAX_VALUE+1);
209 testLongExactTwice(Integer.MAX_VALUE+1, -Integer.MAX_VALUE+1);
210 testLongExactTwice(Integer.MIN_VALUE-1, Integer.MIN_VALUE-1);
211 testLongExactTwice(Integer.MIN_VALUE-1, -Integer.MIN_VALUE-1);
212 testLongExactTwice(Integer.MIN_VALUE/2, 2);
213 }
214
215 /**
216 * Test each of the exact operations with the arguments and
217 * with the arguments reversed.
218 * @param x
219 * @param y
220 */
221 static void testLongExactTwice(long x, long y) {
222 testLongExact(x, y);
223 testLongExact(y, x);
224 }
225
226
227 /**
228 * Test long exact arithmetic by comparing with the same operations using BigInteger
229 * and checking that the result is the same as the long truncation.
230 * Errors are reported with {@link fail}.
231 *
232 * @param x first parameter
233 * @param y second parameter
234 */
235 static void testLongExact(long x, long y) {
236 BigInteger resultBig = null;
237 final BigInteger xBig = BigInteger.valueOf(x);
238 final BigInteger yBig = BigInteger.valueOf(y);
239 try {
240 // Test addExact
241 resultBig = xBig.add(yBig);
242 long sum = Math.addExact(x, y);
243 checkResult("long Math.addExact", x, y, sum, resultBig);
244 } catch (ArithmeticException ex) {
245 if (inLongRange(resultBig)) {
246 fail("FAIL: long Math.addExact(" + x + " + " + y + "); Unexpected exception: " + ex);
247 }
248 }
249
250 try {
251 // Test subtractExact
252 resultBig = xBig.subtract(yBig);
253 long diff = Math.subtractExact(x, y);
254 checkResult("long Math.subtractExact", x, y, diff, resultBig);
255 } catch (ArithmeticException ex) {
256 if (inLongRange(resultBig)) {
257 fail("FAIL: long Math.subtractExact(" + x + " - " + y + ")" + "; Unexpected exception: " + ex);
258 }
259 }
260
261 try {
262 // Test multiplyExact
263 resultBig = xBig.multiply(yBig);
264 long product = Math.multiplyExact(x, y);
265 checkResult("long Math.multiplyExact", x, y, product, resultBig);
266 } catch (ArithmeticException ex) {
267 if (inLongRange(resultBig)) {
268 fail("FAIL: long Math.multiplyExact(" + x + " * " + y + ")" + "; Unexpected exception: " + ex);
269 }
270 }
271
272 try {
273 // Test incrementExact
274 resultBig = xBig.add(BigInteger.ONE);
275 long inc = Math.incrementExact(x);
276 checkResult("long Math.incrementExact", x, 1L, inc, resultBig);
277 } catch (ArithmeticException ex) {
278 if (inLongRange(resultBig)) {
279 fail("FAIL: long Math.incrementExact(" + x + "); Unexpected exception: " + ex);
280 }
281 }
282
283 try {
284 // Test decrementExact
285 resultBig = xBig.subtract(BigInteger.ONE);
286 long dec = Math.decrementExact(x);
287 checkResult("long Math.decrementExact", x, 1L, dec, resultBig);
288 } catch (ArithmeticException ex) {
289 if (inLongRange(resultBig)) {
290 fail("FAIL: long Math.decrementExact(" + x + "); Unexpected exception: " + ex);
291 }
292 }
293
294 try {
295 // Test negateExact
296 resultBig = xBig.negate();
297 long dec = Math.negateExact(x);
298 checkResult("long Math.negateExact", x, 0L, dec, resultBig);
299 } catch (ArithmeticException ex) {
300 if (inLongRange(resultBig)) {
301 fail("FAIL: long Math.negateExact(" + x + "); Unexpected exception: " + ex);
302 }
303 }
304
305 try {
306 // Test toIntExact
307 int value = Math.toIntExact(x);
308 if ((long)value != x) {
309 fail("FAIL: " + "long Math.toIntExact" + "(" + x + ") = " + value + "; expected an arithmetic exception: ");
310 }
311 } catch (ArithmeticException ex) {
312 if (resultBig.bitLength() <= 32) {
313 fail("FAIL: long Math.toIntExact(" + x + ")" + "; Unexpected exception: " + ex);
314 }
315 }
316 }
317
318 /**
319 * Compare the expected and actual results.
320 * @param message message for the error
321 * @param x first argument
322 * @param y second argument
323 * @param result actual result value
324 * @param expected expected result value
325 */
326 static void checkResult(String message, long x, long y, long result, BigInteger expected) {
327 BigInteger resultBig = BigInteger.valueOf(result);
328 if (!inLongRange(expected)) {
329 fail("FAIL: " + message + "(" + x + ", " + y + ") = " + result + "; expected an arithmetic exception: ");
330 } else if (!resultBig.equals(expected)) {
331 fail("FAIL: " + message + "(" + x + ", " + y + ") = " + result + "; expected " + expected);
332 }
333 }
334
335 /**
336 * Check if the value fits in 64 bits (a long).
337 * @param value
338 * @return true if the value fits in 64 bits (including the sign).
339 */
340 static boolean inLongRange(BigInteger value) {
341 return value.bitLength() <= 63;
342 }
343
344 /**
345 * Test Math.multiplyExact method with {@code long} and {@code int}
346 * arguments.
347 */
348 static void testLongIntExact() {
349 testLongIntExact(0, 0);
350 testLongIntExact(1, 1);
351 testLongIntExact(1, -1);
352 testLongIntExact(1000, 2000);
353
354 testLongIntExact(Long.MIN_VALUE, Integer.MIN_VALUE);
355 testLongIntExact(Long.MAX_VALUE, Integer.MAX_VALUE);
356 testLongIntExact(Long.MIN_VALUE, 1);
357 testLongIntExact(Long.MAX_VALUE, 1);
358 testLongIntExact(Long.MIN_VALUE, 2);
359 testLongIntExact(Long.MAX_VALUE, 2);
360 testLongIntExact(Long.MIN_VALUE, -1);
361 testLongIntExact(Long.MAX_VALUE, -1);
362 testLongIntExact(Long.MIN_VALUE, -2);
363 testLongIntExact(Long.MAX_VALUE, -2);
364 testLongIntExact(Long.MIN_VALUE/2, 2);
365 testLongIntExact(Long.MAX_VALUE, 2);
366 testLongIntExact(Integer.MAX_VALUE, Integer.MAX_VALUE);
367 testLongIntExact(Integer.MAX_VALUE, -Integer.MAX_VALUE);
368 testLongIntExact((long)Integer.MAX_VALUE+1L, Integer.MAX_VALUE);
369 testLongIntExact((long)Integer.MAX_VALUE+1L, -Integer.MAX_VALUE+1);
370 testLongIntExact((long)Integer.MIN_VALUE-1L, Integer.MIN_VALUE);
371 testLongIntExact((long)Integer.MIN_VALUE-1, Integer.MAX_VALUE);
372 testLongIntExact(Integer.MIN_VALUE/2, 2);
373 }
374
375 /**
376 * Test long-int exact arithmetic by comparing with the same operations using BigInteger
377 * and checking that the result is the same as the long truncation.
378 * Errors are reported with {@link fail}.
379 *
380 * @param x first parameter
381 * @param y second parameter
382 */
383 static void testLongIntExact(long x, int y) {
384 BigInteger resultBig = null;
385 final BigInteger xBig = BigInteger.valueOf(x);
386 final BigInteger yBig = BigInteger.valueOf(y);
387
388 try {
389 // Test multiplyExact
390 resultBig = xBig.multiply(yBig);
391 long product = Math.multiplyExact(x, y);
392 checkResult("long Math.multiplyExact", x, y, product, resultBig);
393 } catch (ArithmeticException ex) {
394 if (inLongRange(resultBig)) {
395 fail("FAIL: long Math.multiplyExact(" + x + " * " + y + ")" + "; Unexpected exception: " + ex);
396 }
397 }
398 }
399 }