# HG changeset patch # User darcy # Date 1316025131 25200 # Node ID d8173a78bdca6406ede0a5176bccb62a9bcdec1e # Parent 654c00a794b684ecdaee78ce1815ae34050e098f 6879143: java.math.BigInteger misses the xxxValueExact methods Reviewed-by: alanb diff -r 654c00a794b6 -r d8173a78bdca jdk/src/share/classes/java/math/BigInteger.java --- a/jdk/src/share/classes/java/math/BigInteger.java Wed Sep 14 08:33:34 2011 -0700 +++ b/jdk/src/share/classes/java/math/BigInteger.java Wed Sep 14 11:32:11 2011 -0700 @@ -2919,6 +2919,7 @@ * result with the opposite sign. * * @return this BigInteger converted to an {@code int}. + * @see #intValueExact() */ public int intValue() { int result = 0; @@ -2939,6 +2940,7 @@ * result with the opposite sign. * * @return this BigInteger converted to a {@code long}. + * @see #longValueExact() */ public long longValue() { long result = 0; @@ -3382,4 +3384,84 @@ } return result; } + + /** + * Converts this {@code BigInteger} to a {@code long}, checking + * for lost information. If the value of this {@code BigInteger} + * is out of the range of the {@code long} type, then an + * {@code ArithmeticException} is thrown. + * + * @return this {@code BigInteger} converted to a {@code long}. + * @throws ArithmeticException if the value of {@code this} will + * not exactly fit in a {@code long}. + * @see BigInteger#longValue + * @since 1.8 + */ + public long longValueExact() { + if (mag.length <= 2 && bitLength() <= 63) + return longValue(); + else + throw new ArithmeticException("BigInteger out of long range"); + } + + /** + * Converts this {@code BigInteger} to an {@code int}, checking + * for lost information. If the value of this {@code BigInteger} + * is out of the range of the {@code int} type, then an + * {@code ArithmeticException} is thrown. + * + * @return this {@code BigInteger} converted to an {@code int}. + * @throws ArithmeticException if the value of {@code this} will + * not exactly fit in a {@code int}. + * @see BigInteger#intValue + * @since 1.8 + */ + public int intValueExact() { + if (mag.length <= 1 && bitLength() <= 31) + return intValue(); + else + throw new ArithmeticException("BigInteger out of int range"); + } + + /** + * Converts this {@code BigInteger} to a {@code short}, checking + * for lost information. If the value of this {@code BigInteger} + * is out of the range of the {@code short} type, then an + * {@code ArithmeticException} is thrown. + * + * @return this {@code BigInteger} converted to a {@code short}. + * @throws ArithmeticException if the value of {@code this} will + * not exactly fit in a {@code short}. + * @see BigInteger#shortValue + * @since 1.8 + */ + public short shortValueExact() { + if (mag.length <= 1 && bitLength() <= 31) { + int value = intValue(); + if (value >= Short.MIN_VALUE && value <= Short.MAX_VALUE) + return shortValue(); + } + throw new ArithmeticException("BigInteger out of short range"); + } + + /** + * Converts this {@code BigInteger} to a {@code byte}, checking + * for lost information. If the value of this {@code BigInteger} + * is out of the range of the {@code byte} type, then an + * {@code ArithmeticException} is thrown. + * + * @return this {@code BigInteger} converted to a {@code byte}. + * @throws ArithmeticException if the value of {@code this} will + * not exactly fit in a {@code byte}. + * @see BigInteger#byteValue + * @since 1.8 + */ + public byte byteValueExact() { + if (mag.length <= 1 && bitLength() <= 31) { + int value = intValue(); + if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE) + return byteValue(); + } + throw new ArithmeticException("BigInteger out of byte range"); + } } diff -r 654c00a794b6 -r d8173a78bdca jdk/test/java/math/BigInteger/TestValueExact.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/math/BigInteger/TestValueExact.java Wed Sep 14 11:32:11 2011 -0700 @@ -0,0 +1,194 @@ +/* + * Copyright (c) 2011, 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 6371401 + * @summary Tests of fooValueExact methods + * @author Joseph D. Darcy + */ +import java.math.BigInteger; + +public class TestValueExact { + public static void main(String... args) { + int errors = 0; + + errors += testLongValueExact(); + errors += testIntValueExact(); + errors += testShortValueExact(); + errors += testByteValueExact(); + + if (errors > 0) + throw new RuntimeException(); + } + + private static int testLongValueExact() { + int errors = 0; + BigInteger[] inRange = { + BigInteger.valueOf(Long.MIN_VALUE), + BigInteger.ZERO, + BigInteger.valueOf(Long.MAX_VALUE) + }; + + BigInteger[] outOfRange = { + BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE), + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE) + }; + + for (BigInteger bi : inRange) { + if (bi.longValueExact() != bi.longValue()) { + System.err.println("Mismatching int conversion for " + bi); + errors++; + } + } + + for (BigInteger bi : outOfRange) { + try { + long value = bi.longValueExact(); + System.err.println("Failed to get expected exception on " + + bi + " got " + value); + errors++; + } catch(ArithmeticException ae) { + ; // Expected + } + } + return errors; + } + + private static int testIntValueExact() { + int errors = 0; + BigInteger[] inRange = { + BigInteger.valueOf(Integer.MIN_VALUE), + BigInteger.ZERO, + BigInteger.ONE, + BigInteger.TEN, + BigInteger.valueOf(Integer.MAX_VALUE) + }; + + BigInteger[] outOfRange = { + BigInteger.valueOf((long)Integer.MIN_VALUE - 1), + BigInteger.valueOf((long)Integer.MAX_VALUE + 1) + }; + + for (BigInteger bi : inRange) { + if (bi.intValueExact() != bi.intValue()) { + System.err.println("Mismatching int conversion for " + bi); + errors++; + } + } + + for (BigInteger bi : outOfRange) { + try { + int value = bi.intValueExact(); + System.err.println("Failed to get expected exception on " + + bi + " got " + value); + errors++; + } catch(ArithmeticException ae) { + ; // Expected + } + } + return errors; + } + + private static int testShortValueExact() { + int errors = 0; + BigInteger[] inRange = { + BigInteger.valueOf(Short.MIN_VALUE), + BigInteger.ZERO, + BigInteger.ONE, + BigInteger.TEN, + BigInteger.valueOf(Short.MAX_VALUE) + }; + + BigInteger[] outOfRange = { + BigInteger.valueOf((long)Integer.MIN_VALUE - 1), + BigInteger.valueOf((long)Integer.MIN_VALUE), + BigInteger.valueOf( (int)Short.MIN_VALUE - 1), + BigInteger.valueOf( (int)Short.MAX_VALUE + 1), + BigInteger.valueOf((long)Integer.MAX_VALUE), + BigInteger.valueOf((long)Integer.MAX_VALUE + 1) + }; + + for (BigInteger bi : inRange) { + if (bi.shortValueExact() != bi.shortValue()) { + System.err.println("Mismatching short conversion for " + bi); + errors++; + } + } + + for (BigInteger bi : outOfRange) { + try { + int value = bi.shortValueExact(); + System.err.println("Failed to get expected exception on " + + bi + " got " + value); + errors++; + } catch(ArithmeticException ae) { + ; // Expected + } + } + return errors; + } + + private static int testByteValueExact() { + int errors = 0; + BigInteger[] inRange = { + BigInteger.valueOf(Byte.MIN_VALUE), + BigInteger.valueOf(0), + BigInteger.ONE, + BigInteger.TEN, + BigInteger.valueOf(Byte.MAX_VALUE) + }; + + BigInteger[] outOfRange = { + BigInteger.valueOf((long)Integer.MIN_VALUE - 1), + BigInteger.valueOf((long)Integer.MIN_VALUE), + BigInteger.valueOf( (int)Short.MIN_VALUE - 1), + BigInteger.valueOf( (int)Short.MIN_VALUE), + BigInteger.valueOf( (int)Byte.MIN_VALUE - 1), + BigInteger.valueOf( (int)Byte.MAX_VALUE + 1), + BigInteger.valueOf( (int)Short.MAX_VALUE + 1), + BigInteger.valueOf( (int)Short.MAX_VALUE), + BigInteger.valueOf((long)Integer.MAX_VALUE), + BigInteger.valueOf((long)Integer.MAX_VALUE + 1) + }; + + for (BigInteger bi : inRange) { + if (bi.byteValueExact() != bi.byteValue()) { + System.err.println("Mismatching byte conversion for " + bi); + errors++; + } + } + + for (BigInteger bi : outOfRange) { + try { + int value = bi.byteValueExact(); + System.err.println("Failed to get expected exception on " + + bi + " got " + value); + errors++; + } catch(ArithmeticException ae) { + ; // Expected + } + } + return errors; + } +}