diff -r b7465577320f -r f87353679927 test/jdk/java/math/BigInteger/largeMemory/SymmetricRangeTests.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/jdk/java/math/BigInteger/largeMemory/SymmetricRangeTests.java Mon Oct 21 14:04:16 2019 +0800 @@ -0,0 +1,665 @@ +/* + * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 6910473 8021204 8021203 9005933 8074460 8078672 + * @summary Test range of BigInteger values (use -Dseed=X to set PRNG seed) + * @library /test/lib + * @requires os.maxMemory > 8g + * @run main/timeout=180/othervm -Xmx8g SymmetricRangeTests + * @author Dmitry Nadezhin + * @key randomness + */ +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.Arrays; +import java.math.BigInteger; +import java.util.Random; +import jdk.test.lib.RandomFactory; + +public class SymmetricRangeTests { + + private static final BigInteger MAX_VALUE = makeMaxValue(); + private static final BigInteger MIN_VALUE = MAX_VALUE.negate(); + + private static BigInteger makeMaxValue() { + byte[] ba = new byte[1 << 28]; + Arrays.fill(ba, (byte) 0xFF); + ba[0] = (byte) 0x7F; + return new BigInteger(ba); + } + + private static void check(String msg, BigInteger actual, BigInteger expected) { + if (!actual.equals(expected)) { + throw new RuntimeException(msg + ".bitLength()=" + actual.bitLength()); + } + } + + private static void check(String msg, double actual, double expected) { + if (actual != expected) { + throw new RuntimeException(msg + "=" + actual); + } + } + + private static void check(String msg, float actual, float expected) { + if (actual != expected) { + throw new RuntimeException(msg + "=" + actual); + } + } + + private static void check(String msg, long actual, long expected) { + if (actual != expected) { + throw new RuntimeException(msg + "=" + actual); + } + } + + private static void check(String msg, int actual, int expected) { + if (actual != expected) { + throw new RuntimeException(msg + "=" + actual); + } + } + + private static void testOverflowInMakePositive() { + System.out.println("Testing overflow in BigInteger.makePositive"); + byte[] ba = new byte[Integer.MAX_VALUE - 2]; + ba[0] = (byte) 0x80; + try { + BigInteger actual = new BigInteger(ba); + throw new RuntimeException("new BigInteger(ba).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testBug8021204() { + System.out.println("Testing Bug 8021204"); + StringBuilder sb = new StringBuilder(); + sb.append('1'); + for (int i = 0; i < (1 << 30) - 1; i++) { + sb.append('0'); + } + sb.append('1'); + String s = sb.toString(); + sb = null; + try { + BigInteger actual = new BigInteger(s, 16); + throw new RuntimeException("new BigInteger(\"1000...001\").bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testOverflowInBitSieve() { + System.out.println("Testing overflow in BitSieve.sieveSingle"); + int bitLength = (5 << 27) - 1; + try { + Random random = RandomFactory.getRandom(); + BigInteger actual = new BigInteger(bitLength, 0, random); + throw new RuntimeException("new BigInteger(bitLength, 0, null).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + try { + BigInteger bi = BigInteger.ONE.shiftLeft(bitLength - 1).subtract(BigInteger.ONE); + BigInteger actual = bi.nextProbablePrime(); + throw new RuntimeException("bi.nextActualPrime().bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testAdd() { + System.out.println("Testing BigInteger.add"); + try { + BigInteger actual = MAX_VALUE.add(BigInteger.ONE); + throw new RuntimeException("BigInteger.MAX_VALUE.add(BigInteger.ONE).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testSubtract() { + System.out.println("Testing BigInteger.subtract"); + try { + BigInteger actual = MIN_VALUE.subtract(BigInteger.ONE); + throw new RuntimeException("BigInteger.MIN_VALUE.subtract(BigInteger.ONE).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testMultiply() { + System.out.println("Testing BigInteger.multiply"); + int py = 2000; + int px = Integer.MAX_VALUE - py; + BigInteger x = BigInteger.ONE.shiftLeft(px); + BigInteger y = BigInteger.ONE.shiftLeft(py); + try { + BigInteger actual = x.multiply(y); + throw new RuntimeException("(1 << " + px + " ) * (1 << " + py + ").bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testDivide() { + System.out.println("Testing BigInteger.divide"); + check("BigInteger.MIN_VALUE.divide(BigInteger.valueOf(-1))", + MIN_VALUE.divide(BigInteger.valueOf(-1)), MAX_VALUE); + check("BigInteger.MIN_VALUE.divide(BigInteger.ONE)", + MIN_VALUE.divide(BigInteger.ONE), MIN_VALUE); + } + + private static void testDivideAndRemainder(String msg, BigInteger dividend, BigInteger divisor, + BigInteger expectedQuotent, BigInteger expectedRemainder) { + BigInteger[] qr = dividend.divideAndRemainder(divisor); + check(msg + "[0]", qr[0], expectedQuotent); + check(msg + "[1]", qr[1], expectedRemainder); + } + + private static void testDivideAndRemainder() { + System.out.println("Testing BigInteger.divideAndRemainder"); + testDivideAndRemainder("BigInteger.MIN_VALUE.divideAndRemainder(BigInteger.valueOf(-1))", + MIN_VALUE, BigInteger.valueOf(-1), + MAX_VALUE, + BigInteger.ZERO); + } + + private static void testBug9005933() { + System.out.println("Testing Bug 9005933"); + int dividendPow = 2147483646; + int divisorPow = 1568; + BigInteger dividend = BigInteger.ONE.shiftLeft(dividendPow); + BigInteger divisor = BigInteger.ONE.shiftLeft(divisorPow); + testDivideAndRemainder("(1 << " + dividendPow + ").divideAndRemainder(1 << " + divisorPow + ")", + dividend, divisor, + BigInteger.ONE.shiftLeft(dividendPow - divisorPow), + BigInteger.ZERO); + } + + private static void testRemainder() { + System.out.println("Testing BigInteger.remainder"); + check("BigInteger.MIN_VALUE.remainder(BigInteger.valueOf(-1))", + MIN_VALUE.remainder(BigInteger.valueOf(-1)), BigInteger.ZERO); + } + + private static void testPow() { + System.out.println("Testing BigInteger.pow"); + check("BigInteger.MIN_VALUE.pow(1)", + MIN_VALUE.pow(1), MIN_VALUE); + try { + BigInteger actual = BigInteger.valueOf(4).pow(Integer.MAX_VALUE); + throw new RuntimeException("BigInteger.valueOf(4).pow(Integer.MAX_VALUE).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testGcd() { + System.out.println("Testing BigInteger.gcd"); + check("BigInteger.MIN_VALUE.gcd(BigInteger.MIN_VALUE)", + MIN_VALUE.gcd(MIN_VALUE), MAX_VALUE); + check("BigInteger.MIN_VALUE.gcd(BigInteger.ZERO)", + MIN_VALUE.gcd(BigInteger.ZERO), MAX_VALUE); + check("BigInteger.ZERO.gcd(MIN_VALUE)", + BigInteger.ZERO.gcd(MIN_VALUE), MAX_VALUE); + } + + private static void testAbs() { + System.out.println("Testing BigInteger.abs"); + check("BigInteger.MIN_VALUE.abs()", + MIN_VALUE.abs(), MAX_VALUE); + check("BigInteger.MAX_VALUE.abs()", + MAX_VALUE.abs(), MAX_VALUE); + } + + private static void testNegate() { + System.out.println("Testing BigInteger.negate"); + check("BigInteger.MIN_VALUE.negate()", + MIN_VALUE.negate(), MAX_VALUE); + check("BigInteger.MAX_VALUE.negate()", + MAX_VALUE.negate(), MIN_VALUE); + } + + private static void testMod() { + System.out.println("Testing BigInteger.mod"); + check("BigInteger.MIN_VALUE.mod(BigInteger.MAX_VALUE)", + MIN_VALUE.mod(MAX_VALUE), BigInteger.ZERO); + check("BigInteger.MAX_VALUE.mod(BigInteger.MAX_VALUE)", + MIN_VALUE.mod(MAX_VALUE), BigInteger.ZERO); + } + + private static void testModPow() { + System.out.println("Testing BigInteger.modPow"); + BigInteger x = BigInteger.valueOf(3); + BigInteger m = BigInteger.valueOf(-4).subtract(MIN_VALUE); + check("BigInteger.valueOf(3).modPow(BigInteger.ONE, m)", + x.modPow(BigInteger.ONE, m), x); + } + + // slow test + private static void testModInverse() { + System.out.println("Testing BigInteger.modInverse"); + check("BigInteger.MIN_VALUE.modInverse(BigInteger.MAX_VALUE)", + MIN_VALUE.modInverse(MAX_VALUE), MAX_VALUE.subtract(BigInteger.ONE)); + } + + private static void testShiftLeft() { + System.out.println("Testing BigInteger.shiftLeft"); + try { + BigInteger actual = MIN_VALUE.shiftLeft(1); + throw new RuntimeException("BigInteger.MIN_VALUE.shiftLeft(1).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + try { + BigInteger actual = MAX_VALUE.shiftLeft(1); + throw new RuntimeException("BigInteger.MAX_VALUE.shiftLeft(1).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testShiftRight() { + System.out.println("Testing BigInteger.shiftRight"); + try { + BigInteger actual = MIN_VALUE.shiftRight(-1); + throw new RuntimeException("BigInteger.MIN_VALUE.shiftRight(-1).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + try { + BigInteger actual = MAX_VALUE.shiftRight(-1); + throw new RuntimeException("BigInteger.MAX_VALUE.shiftRight(-1).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testAnd() { + System.out.println("Testing BigInteger.and"); + check("BigInteger.MIN_VALUE.and(BigInteger.MIN_VALUE)", + MIN_VALUE.and(MIN_VALUE), MIN_VALUE); + check("BigInteger.MAX_VALUE.and(BigInteger.MAX_VALUE)", + MAX_VALUE.and(MAX_VALUE), MAX_VALUE); + check("BigInteger.MIN_VALUE.and(BigInteger.MAX_VALUE)", + MIN_VALUE.and(MAX_VALUE), BigInteger.ONE); + try { + BigInteger actual = MIN_VALUE.and(BigInteger.valueOf(-2)); + throw new RuntimeException("BigInteger.MIN_VALUE.and(-2)).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testOr() { + System.out.println("Testing BigInteger.or"); + check("BigInteger.MIN_VALUE.or(BigInteger.MIN_VALUE)", + MIN_VALUE.or(MIN_VALUE), MIN_VALUE); + check("BigInteger.MAX_VALUE.or(BigInteger.MAX_VALUE)", + MAX_VALUE.or(MAX_VALUE), MAX_VALUE); + check("BigInteger.MIN_VALUE.and(BigInteger.MAX_VALUE)", + MIN_VALUE.or(MAX_VALUE), BigInteger.valueOf(-1)); + } + + private static void testXor() { + System.out.println("Testing BigInteger.xor"); + check("BigInteger.MIN_VALUE.xor(BigInteger.MIN_VALUE)", + MIN_VALUE.xor(MIN_VALUE), BigInteger.ZERO); + check("BigInteger.MAX_VALUE.xor(BigInteger.MAX_VALUE)", + MAX_VALUE.xor(MAX_VALUE), BigInteger.ZERO); + check("BigInteger.MIN_VALUE.xor(BigInteger.MAX_VALUE)", + MIN_VALUE.xor(MAX_VALUE), BigInteger.valueOf(-2)); + try { + BigInteger actual = MIN_VALUE.xor(BigInteger.ONE); + throw new RuntimeException("BigInteger.MIN_VALUE.xor(BigInteger.ONE)).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testNot() { + System.out.println("Testing BigInteger.not"); + check("BigInteger.MIN_VALUE.not()", + MIN_VALUE.not(), MAX_VALUE.subtract(BigInteger.ONE)); + try { + BigInteger actual = MAX_VALUE.not(); + throw new RuntimeException("BigInteger.MAX_VALUE.not()).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testSetBit() { + System.out.println("Testing BigInteger.setBit"); + check("BigInteger.MIN_VALUE.setBit(" + Integer.MAX_VALUE + ")", + MIN_VALUE.setBit(Integer.MAX_VALUE), MIN_VALUE); + try { + BigInteger actual = MAX_VALUE.setBit(Integer.MAX_VALUE); + throw new RuntimeException("BigInteger.MAX_VALUE.setBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testClearBit() { + System.out.println("Testing BigInteger.clearBit"); + check("BigInteger.MAX_VALUE.clearBit(" + Integer.MAX_VALUE + ")", + MAX_VALUE.clearBit(Integer.MAX_VALUE), MAX_VALUE); + try { + BigInteger actual = MIN_VALUE.clearBit(Integer.MAX_VALUE); + throw new RuntimeException("BigInteger.MIN_VALUE.clearBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + try { + BigInteger actual = MIN_VALUE.clearBit(0); + throw new RuntimeException("BigInteger.MIN_VALUE.clearBit(0).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testFlipBit() { + System.out.println("Testing BigInteger.flipBit"); + try { + BigInteger actual = MIN_VALUE.flipBit(Integer.MAX_VALUE); + throw new RuntimeException("BigInteger.MIN_VALUE.flipBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + try { + BigInteger actual = MIN_VALUE.flipBit(0); + throw new RuntimeException("BigInteger.MIN_VALUE.flipBit(0).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + try { + BigInteger actual = MAX_VALUE.flipBit(Integer.MAX_VALUE); + throw new RuntimeException("BigInteger.MAX_VALUE.flipBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testGetLowestSetBit() { + System.out.println("Testing BigInteger.getLowestSetBit"); + check("BigInteger.MIN_VALUE.getLowestSetBit()", + MIN_VALUE.getLowestSetBit(), 0); + check("BigInteger.MAX_VALUE.getLowestSetBit()", + MAX_VALUE.getLowestSetBit(), 0); + } + + private static void testBitLength() { + System.out.println("Testing BigInteger.bitLength"); + check("BigInteger.MIN_NEXT.bitLength()", + MIN_VALUE.bitLength(), Integer.MAX_VALUE); + check("BigInteger.MAX_VALUE.bitLength()", + MAX_VALUE.bitLength(), Integer.MAX_VALUE); + } + + private static void testBitCount() { + System.out.println("Testing BigInteger.bitCount"); + check("BigInteger.MIN_VALUE.bitCount()", + MIN_VALUE.bitCount(), Integer.MAX_VALUE - 1); + check("BigInteger.MAX_VALUE.bitCount()", + MAX_VALUE.bitCount(), Integer.MAX_VALUE); + } + + private static void testToString(String msg, int radix, BigInteger bi, int length, String startsWith, char c) { + String s = bi.toString(radix); + if (s.length() != length) { + throw new RuntimeException(msg + ".length=" + s.length()); + } + if (!s.startsWith(startsWith)) { + throw new RuntimeException(msg + "[0]=" + s.substring(0, startsWith.length())); + } + for (int i = startsWith.length(); i < s.length(); i++) { + if (s.charAt(i) != c) { + throw new RuntimeException(msg + "[" + i + "]='" + s.charAt(i) + "'"); + } + } + } + + private static void testToString() { + System.out.println("Testing BigInteger.toString"); + testToString("BigInteger.MIN_VALUE.toString(16)=", 16, + BigInteger.valueOf(-1).shiftLeft(Integer.MAX_VALUE - 1), + (1 << 29) + 1, "-4", '0'); + } + + private static void testToByteArrayWithConstructor(String msg, BigInteger bi, int length, byte msb, byte b, byte lsb) { + byte[] ba = bi.toByteArray(); + if (ba.length != length) { + throw new RuntimeException(msg + ".length=" + ba.length); + } + if (ba[0] != msb) { + throw new RuntimeException(msg + "[0]=" + ba[0]); + } + for (int i = 1; i < ba.length - 1; i++) { + if (ba[i] != b) { + throw new RuntimeException(msg + "[" + i + "]=" + ba[i]); + } + } + if (ba[ba.length - 1] != lsb) { + throw new RuntimeException(msg + "[" + (ba.length - 1) + "]=" + ba[ba.length - 1]); + } + BigInteger actual = new BigInteger(ba); + if (!actual.equals(bi)) { + throw new RuntimeException(msg + ".bitLength()=" + actual.bitLength()); + } + } + + private static void testToByteArrayWithConstructor() { + System.out.println("Testing BigInteger.toByteArray with constructor"); + testToByteArrayWithConstructor("BigInteger.MIN_VALUE.toByteArray()", + MIN_VALUE, (1 << 28), (byte) 0x80, (byte) 0x00, (byte) 0x01); + testToByteArrayWithConstructor("BigInteger.MAX_VALUE.toByteArray()", + MAX_VALUE, (1 << 28), (byte) 0x7f, (byte) 0xff, (byte) 0xff); + + byte[] ba = new byte[1 << 28]; + ba[0] = (byte) 0x80; + try { + BigInteger actual = new BigInteger(-1, ba); + throw new RuntimeException("new BigInteger(-1, ba).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + try { + BigInteger actual = new BigInteger(1, ba); + throw new RuntimeException("new BigInteger(1, ba).bitLength()=" + actual.bitLength()); + } catch (ArithmeticException e) { + // expected + } + } + + private static void testIntValue() { + System.out.println("Testing BigInteger.intValue"); + check("BigInteger.MIN_VALUE.intValue()", + MIN_VALUE.intValue(), 1); + check("BigInteger.MAX_VALUE.floatValue()", + MAX_VALUE.intValue(), -1); + } + + private static void testLongValue() { + System.out.println("Testing BigInteger.longValue"); + check("BigInteger.MIN_VALUE.longValue()", + MIN_VALUE.longValue(), 1L); + check("BigInteger.MAX_VALUE.longValue()", + MAX_VALUE.longValue(), -1L); + } + + private static void testFloatValue() { + System.out.println("Testing BigInteger.floatValue, Bug 8021203"); + check("BigInteger.MIN_VALUE_.floatValue()", + MIN_VALUE.floatValue(), Float.NEGATIVE_INFINITY); + check("BigInteger.MAX_VALUE.floatValue()", + MAX_VALUE.floatValue(), Float.POSITIVE_INFINITY); + } + + private static void testDoubleValue() { + System.out.println("Testing BigInteger.doubleValue, Bug 8021203"); + check("BigInteger.MIN_VALUE.doubleValue()", + MIN_VALUE.doubleValue(), Double.NEGATIVE_INFINITY); + check("BigInteger.MAX_VALUE.doubleValue()", + MAX_VALUE.doubleValue(), Double.POSITIVE_INFINITY); + } + + private static void testSerialization(String msg, BigInteger bi) { + try { + ByteArrayOutputStream baOut = new ByteArrayOutputStream((1 << 28) + 1000); + ObjectOutputStream out = new ObjectOutputStream(baOut); + out.writeObject(bi); + out.close(); + out = null; + byte[] ba = baOut.toByteArray(); + baOut = null; + ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(ba)); + BigInteger actual = (BigInteger) in.readObject(); + if (!actual.equals(bi)) { + throw new RuntimeException(msg + ".bitLength()=" + actual.bitLength()); + } + } catch (IOException | ClassNotFoundException e) { + throw new RuntimeException(msg + " raised exception ", e); + } + } + + private static void testSerialization() { + System.out.println("Testing BigInteger serialization"); + testSerialization("BigInteger.MIN_VALUE.intValue()", + MIN_VALUE); + testSerialization("BigInteger.MAX_VALUE.floatValue()", + MAX_VALUE); + } + + private static void testLongValueExact() { + System.out.println("Testing BigInteger.longValueExact"); + try { + long actual = MIN_VALUE.longValueExact(); + throw new RuntimeException("BigInteger.MIN_VALUE.longValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + try { + long actual = MAX_VALUE.longValueExact(); + throw new RuntimeException("BigInteger.MAX_VALUE.longValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + } + + private static void testIntValueExact() { + System.out.println("Testing BigInteger.intValueExact"); + try { + long actual = MIN_VALUE.intValueExact(); + throw new RuntimeException("BigInteger.MIN_VALUE.intValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + try { + long actual = MAX_VALUE.intValueExact(); + throw new RuntimeException("BigInteger.MAX_VALUE.intValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + } + + private static void testShortValueExact() { + System.out.println("Testing BigInteger.shortValueExact"); + try { + long actual = MIN_VALUE.shortValueExact(); + throw new RuntimeException("BigInteger.MIN_VALUE.shortValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + try { + long actual = MAX_VALUE.shortValueExact(); + throw new RuntimeException("BigInteger.MAX_VALUE.shortValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + } + + private static void testByteValueExact() { + System.out.println("Testing BigInteger.byteValueExact"); + try { + long actual = MIN_VALUE.byteValueExact(); + throw new RuntimeException("BigInteger.MIN_VALUE.byteValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + try { + long actual = MAX_VALUE.byteValueExact(); + throw new RuntimeException("BigInteger.MAX_VALUE.byteValueExact()= " + actual); + } catch (ArithmeticException e) { + // excpected + } + } + + public static void main(String... args) { + testOverflowInMakePositive(); + testBug8021204(); + testOverflowInBitSieve(); + testAdd(); + testSubtract(); + testMultiply(); + testDivide(); + testDivideAndRemainder(); + testBug9005933(); + testRemainder(); + testPow(); + testGcd(); + testAbs(); + testNegate(); + testMod(); + testModPow(); +// testModInverse(); + testShiftLeft(); + testShiftRight(); + testAnd(); + testOr(); + testXor(); + testNot(); + testSetBit(); + testClearBit(); + testFlipBit(); + testGetLowestSetBit(); + testBitLength(); + testBitCount(); + testToString(); + testToByteArrayWithConstructor(); + testIntValue(); + testLongValue(); + testFloatValue(); + testDoubleValue(); + testSerialization(); + testLongValueExact(); + testIntValueExact(); + testShortValueExact(); + testByteValueExact(); + } +}