--- a/jdk/src/share/classes/java/lang/SafeVarargs.java Wed Sep 14 21:43:42 2011 -0700
+++ b/jdk/src/share/classes/java/lang/SafeVarargs.java Wed Sep 14 22:36:02 2011 -0700
@@ -82,6 +82,7 @@
*
* </ul>
*
+ * @since 1.7
* @jls 4.7 Reifiable Types
* @jls 8.4.1 Formal Parameters
*/
--- a/jdk/src/share/classes/java/math/BigInteger.java Wed Sep 14 21:43:42 2011 -0700
+++ b/jdk/src/share/classes/java/math/BigInteger.java Wed Sep 14 22:36:02 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");
+ }
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/math/BigInteger/TestValueExact.java Wed Sep 14 22:36:02 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;
+ }
+}