| /* |
| * Copyright 2009 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with this |
| * work for additional information regarding copyright ownership. The ASF |
| * licenses this file to You under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| * |
| * INCLUDES MODIFICATIONS BY GOOGLE. |
| */ |
| /** |
| * author Elena Semukhina |
| */ |
| package com.google.gwt.emultest.java8.math; |
| |
| import com.google.gwt.emultest.java.util.EmulTestBase; |
| |
| import java.math.BigInteger; |
| |
| /** |
| * Class: java.math.BigInteger Methods: intValue, longValue, toByteArray(), |
| * valueOf(long val), floatValue(), doubleValue(). |
| */ |
| public class BigIntegerConvertTest extends EmulTestBase { |
| |
| public void testByteValueExact() { |
| assertEquals(-1, BigInteger.valueOf(-1).byteValueExact()); |
| assertEquals(0, BigInteger.valueOf(0).byteValueExact()); |
| assertEquals(1, BigInteger.valueOf(1).byteValueExact()); |
| assertEquals(Byte.MAX_VALUE, BigInteger.valueOf(Byte.MAX_VALUE).byteValueExact()); |
| assertEquals(Byte.MIN_VALUE, BigInteger.valueOf(Byte.MIN_VALUE).byteValueExact()); |
| |
| try { |
| BigInteger.valueOf(Byte.MAX_VALUE + 1).byteValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| try { |
| BigInteger.valueOf(Byte.MIN_VALUE - 1).byteValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| } |
| |
| /** |
| * Convert a negative number to a double value. The number's bit length is |
| * less than 64 bits. |
| */ |
| public void testDoubleValueNegative1() { |
| String a = "-27467238945"; |
| double result = -2.7467238945E10; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a negative number to a double value. The number's bit length is |
| * inside [63, 1024]. |
| */ |
| public void testDoubleValueNegative2() { |
| String a = "-2746723894572364578265426346273456972"; |
| double result = -2.7467238945723645E36; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a negative number to a double value. The number's bit length is |
| * greater than 1024. |
| */ |
| public void testDoubleValueNegativeInfinity1() { |
| String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == Double.NEGATIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a negative number to a double value. The exponent is 1023 and the |
| * mantissa is all 0s. The rounding bit is 0. The result is |
| * Double.NEGATIVE_INFINITY. |
| */ |
| public void testDoubleValueNegativeInfinity2() { |
| byte[] a = { |
| -1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == Double.NEGATIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The exponent is 1023 and the |
| * mantissa is all 0s but the 54th bit (implicit) is 1. |
| */ |
| public void testDoubleValueNegMantissaIsZero() { |
| byte[] a = { |
| -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == -8.98846567431158E307); |
| } |
| |
| /** |
| * Convert a negative number to a double value. The exponent is 1023 and the |
| * mantissa is all 1s. The result is -Double.MAX_VALUE. |
| */ |
| public void testDoubleValueNegMaxValue() { |
| byte[] a = { |
| 0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1}; |
| int aSign = -1; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == -Double.MAX_VALUE); |
| } |
| |
| /** |
| * Convert a positive number to a double value. Rounding is NOT needed. |
| */ |
| public void testDoubleValueNegNotRounded() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5}; |
| int aSign = -1; |
| double result = -1.5474726438794828E26; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. Rounding is needed. |
| */ |
| public void testDoubleValueNegRounded1() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = -1; |
| double result = -1.54747264387948E26; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. Rounding is needed. The |
| * rounding bit is 1 and the next bit to the left is 0 but some of dropped |
| * bits are 1s. |
| */ |
| public void testDoubleValueNegRounded2() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5}; |
| int aSign = -1; |
| double result = -1.547472643879479E26; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The number's length is less |
| * than 64 bits. |
| */ |
| public void testDoubleValuePositive1() { |
| String a = "27467238945"; |
| double result = 2.7467238945E10; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The number's bit length is |
| * inside [63, 1024]. |
| */ |
| public void testDoubleValuePositive2() { |
| String a = "2746723894572364578265426346273456972"; |
| double result = 2.7467238945723645E36; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The exponent is 1023 and the |
| * mantissa is all 1s. The rounding bit is 1. The result is |
| * Double.POSITIVE_INFINITY. |
| */ |
| public void testDoubleValuePositiveInfinity1() { |
| byte[] a = { |
| -1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = 1; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == Double.POSITIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The number's bit length is |
| * greater than 1024. |
| */ |
| public void testDoubleValuePositiveInfinity2() { |
| String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == Double.POSITIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The exponent is 1023 and the |
| * mantissa is all 0s but the 54th bit (implicit) is 1. |
| */ |
| public void testDoubleValuePosMantissaIsZero() { |
| byte[] a = { |
| -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = 1; |
| double result = 8.98846567431158E307; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The exponent is 1023 and the |
| * mantissa is all 1s. The rounding bit is 0. The result is Double.MAX_VALUE. |
| */ |
| public void testDoubleValuePosMaxValue() { |
| byte[] a = { |
| 0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1}; |
| int aSign = 1; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == Double.MAX_VALUE); |
| } |
| |
| /** |
| * Convert a positive number to a double value. Rounding is NOT needed. |
| */ |
| public void testDoubleValuePosNotRounded() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5}; |
| int aSign = 1; |
| double result = 1.5474726438794828E26; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. Rounding is needed. The |
| * rounding bit is 1 and the next bit to the left is 1. |
| */ |
| public void testDoubleValuePosRounded1() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = 1; |
| double result = 1.54747264387948E26; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. Rounding is needed. The |
| * rounding bit is 1 and the next bit to the left is 0 but some of dropped |
| * bits are 1s. |
| */ |
| public void testDoubleValuePosRounded2() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5}; |
| int aSign = 1; |
| double result = 1.547472643879479E26; |
| double aNumber = new BigInteger(aSign, a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Return the double value of ZERO. |
| */ |
| public void testDoubleValueZero() { |
| String a = "0"; |
| double result = 0.0; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a negative number to a float value. The number's bit length is less |
| * than 32 bits. |
| */ |
| public void testFloatValueBug2482() { |
| String a = "2147483649"; |
| float result = 2.14748365E9f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals("incorrect value", aNumber, result, 1); |
| } |
| |
| /** |
| * Convert a negative number to a float value. The value is near |
| * Float.MAX_VALUE, but since all calculation in JS is done in double |
| * precision, it can't be completely accurate about passing that value |
| * through. |
| */ |
| public void testFloatValueNearNegMaxValue() { |
| byte[] a = { |
| 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(-3.4028235e38, aNumber, 1e31); |
| } |
| |
| /** |
| * Convert a positive number to a float value. The value is near |
| * Float.MAX_VALUE, but since all calculation in JS is done in double |
| * precision, it can't be completely accurate about passing that value |
| * through. |
| */ |
| public void testFloatValueNearPosMaxValue() { |
| byte[] a = { |
| 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = 1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(3.4028235e38, aNumber, 1e31); |
| } |
| |
| /** |
| * Convert a negative number to a float value. The number's bit length is less |
| * than 32 bits. |
| */ |
| public void testFloatValueNegative1() { |
| String a = "-27467238"; |
| float result = -2.7467238E7f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals("incorrect value", result, aNumber, 1); |
| } |
| |
| /** |
| * Convert a negative number to a double value. The number's bit length |
| * is inside [63, 1024]. |
| */ |
| public void testFloatValueNegative2() { |
| String a = "-27467238945723645782"; |
| float result = -2.7467239E19f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals("incorrect value", result, aNumber, 1e12); |
| } |
| |
| /** |
| * Convert a negative number to a float value. The number's bit length is |
| * greater than 127. |
| */ |
| public void testFloatValueNegativeInfinity1() { |
| String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals("incorrect value", Float.NEGATIVE_INFINITY, aNumber); |
| } |
| |
| /** |
| * Convert a negative number to a float value. The exponent is 1023 and the |
| * mantissa is all 0s. The rounding bit is 0. The result is |
| * Float.NEGATIVE_INFINITY. |
| */ |
| public void testFloatValueNegativeInfinity2() { |
| byte[] a = { |
| 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; |
| int aSign = -1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(Float.NEGATIVE_INFINITY, aNumber); |
| } |
| |
| /** |
| * Convert a positive number to a double value. The exponent is 1023 and the |
| * mantissa is all 0s but the 54th bit (implicit) is 1. |
| */ |
| public void testFloatValueNegMantissaIsZero() { |
| byte[] a = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(Float.NEGATIVE_INFINITY, aNumber); |
| } |
| |
| /** |
| * Convert a positive number to a float value. Rounding is NOT needed. |
| */ |
| public void testFloatValueNegNotRounded() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = -1; |
| float result = -1.5474726E26f; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(result, aNumber, 1e19); |
| } |
| |
| /** |
| * Convert a positive number to a float value. Rounding is needed. |
| */ |
| public void testFloatValueNegRounded1() { |
| byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = -1; |
| float result = -1.5475195E26f; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(result, aNumber, 1e19); |
| } |
| |
| /** |
| * Convert a positive number to a float value. Rounding is needed. The |
| * rounding bit is 1 and the next bit to the left is 0 but some of dropped |
| * bits are 1s. |
| */ |
| public void testFloatValueNegRounded2() { |
| byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = -1; |
| float result = -1.5474728E26f; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(result, aNumber, 1e19); |
| } |
| |
| /** |
| * Convert a negative number beyond Float.MAX_VALUE, ensuring that it is |
| * converted to Float.NEGATIVE_INFINITY. |
| */ |
| public void testFloatValuePastNegMaxValue() { |
| byte[] a = { |
| 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; |
| int aSign = -1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(Float.NEGATIVE_INFINITY, aNumber); |
| } |
| |
| /** |
| * Convert a positive number beyond Float.MAX_VALUE, ensuring that it is |
| * converted to Float.POSITIVE_INFINITY. |
| */ |
| public void testFloatValuePastPosMaxValue() { |
| byte[] a = { |
| 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; |
| int aSign = 1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(Float.POSITIVE_INFINITY, aNumber); |
| } |
| |
| /** |
| * Convert a positive number to a float value. The number's length is less |
| * than 32 bits. |
| */ |
| public void testFloatValuePositive1() { |
| String a = "27467238"; |
| float result = 2.7467238E7f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals(result, aNumber); |
| } |
| |
| /** |
| * Convert a positive number to a float value. The number's bit length is |
| * inside [32, 127]. |
| */ |
| public void testFloatValuePositive2() { |
| String a = "27467238945723645782"; |
| float result = 2.7467239E19f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals(result, aNumber, 1e12); |
| } |
| |
| /** |
| * Convert a positive number to a float value. The exponent is 1023 and the |
| * mantissa is all 1s. The rounding bit is 1. The result is |
| * Float.POSITIVE_INFINITY. |
| */ |
| public void testFloatValuePositiveInfinity1() { |
| byte[] a = { |
| 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; |
| int aSign = 1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(Float.POSITIVE_INFINITY, aNumber); |
| } |
| |
| /** |
| * Convert a positive number to a float value. The number's bit length is |
| * greater than 127. |
| */ |
| public void testFloatValuePositiveInfinity2() { |
| String a = "274672389457236457826542634627345697228374687236476867674746234" |
| + "23423423423423423423234234234234234234267674563457452937623847562384" |
| + "75634563456845634568934568347586346578648576478568456457634875673845" |
| + "67845678658734587364576745683475674576345786348576847567846578345670" |
| + "2897830296720476846578634576384567845678346573465786457863"; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals(Float.POSITIVE_INFINITY, aNumber); |
| } |
| |
| /** |
| * Convert a positive number to a float value. The exponent is 1023 and the |
| * mantissa is all 0s but the 54th bit (implicit) is 1. |
| */ |
| public void testFloatValuePosMantissaIsZero() { |
| byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = 1; |
| float result = 1.7014118E38f; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(result, aNumber, 1e31); |
| } |
| |
| /** |
| * Convert a positive number to a float value. Rounding is NOT needed. |
| */ |
| public void testFloatValuePosNotRounded() { |
| byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = 1; |
| float result = 1.5474726E26f; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(result, aNumber, 1e19); |
| } |
| |
| /** |
| * Convert a positive number to a float value. Rounding is needed. The |
| * rounding bit is 1 and the next bit to the left is 1. |
| */ |
| public void testFloatValuePosRounded1() { |
| byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = 1; |
| float result = 1.5475195E26f; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(result, aNumber, 1e19); |
| } |
| |
| /** |
| * Convert a positive number to a float value. Rounding is needed. The |
| * rounding bit is 1 and the next bit to the left is 0 but some of dropped |
| * bits are 1s. |
| */ |
| public void testFloatValuePosRounded2() { |
| byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5}; |
| int aSign = 1; |
| float result = 1.5474728E26f; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertEquals(result, aNumber, 1e19); |
| } |
| |
| /** |
| * Return the float value of ZERO. |
| */ |
| public void testFloatValueZero() { |
| String a = "0"; |
| float result = 0.0f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertEquals(result, aNumber); |
| } |
| |
| /** |
| * Convert a negative BigInteger to an integer value. The low digit is |
| * negative. |
| */ |
| public void testIntValueNegative1() { |
| byte aBytes[] = {12, 56, 100, -2, -76, -128, 45, 91, 3}; |
| int sign = -1; |
| int resInt = 2144511229; |
| int aNumber = new BigInteger(sign, aBytes).intValue(); |
| assertEquals(resInt, aNumber); |
| } |
| |
| /** |
| * Convert a negative BigInteger to an integer value. The low digit is |
| * negative. |
| */ |
| public void testIntValueNegative2() { |
| byte aBytes[] = {-12, 56, 100}; |
| int result = -771996; |
| int aNumber = new BigInteger(aBytes).intValue(); |
| assertEquals(result, aNumber); |
| } |
| |
| /** |
| * Convert a negative BigInteger to an integer value. The low digit is |
| * positive. |
| */ |
| public void testIntValueNegative3() { |
| byte aBytes[] = {12, 56, 100, -2, -76, 127, 45, 91, 3}; |
| int sign = -1; |
| int resInt = -2133678851; |
| int aNumber = new BigInteger(sign, aBytes).intValue(); |
| assertEquals(resInt, aNumber); |
| } |
| |
| public void testIntValueMinIntValue() { |
| assertEquals(Integer.MIN_VALUE, BigInteger.valueOf(Integer.MIN_VALUE).intValue()); |
| } |
| |
| /** |
| * Convert a positive BigInteger to an integer value. The low digit is |
| * positive |
| */ |
| public void testIntValuePositive1() { |
| byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3}; |
| int resInt = 1496144643; |
| int aNumber = new BigInteger(aBytes).intValue(); |
| assertEquals(resInt, aNumber); |
| } |
| |
| /** |
| * Convert a positive BigInteger to an integer value. The low digit is |
| * positive |
| */ |
| public void testIntValuePositive2() { |
| byte aBytes[] = {12, 56, 100}; |
| int resInt = 800868; |
| int aNumber = new BigInteger(aBytes).intValue(); |
| assertEquals(resInt, aNumber); |
| } |
| |
| /** |
| * Convert a positive BigInteger to an integer value. The low digit is |
| * negative. |
| */ |
| public void testIntValuePositive3() { |
| byte aBytes[] = {56, 13, 78, -12, -5, 56, 100}; |
| int sign = 1; |
| int resInt = -184862620; |
| int aNumber = new BigInteger(sign, aBytes).intValue(); |
| assertEquals(resInt, aNumber); |
| } |
| |
| public void testIntValueExact() { |
| assertEquals(-1, BigInteger.valueOf(-1).intValueExact()); |
| assertEquals(0, BigInteger.valueOf(0).intValueExact()); |
| assertEquals(1, BigInteger.valueOf(1).intValueExact()); |
| assertEquals(Integer.MAX_VALUE, BigInteger.valueOf(Integer.MAX_VALUE).intValueExact()); |
| assertEquals(Integer.MIN_VALUE, BigInteger.valueOf(Integer.MIN_VALUE).intValueExact()); |
| |
| try { |
| BigInteger.valueOf(Integer.MAX_VALUE + 1L).intValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| try { |
| BigInteger.valueOf(Integer.MIN_VALUE - 1L).intValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| } |
| |
| /** |
| * Convert a number to a negative long value The BigInteger is longer than |
| * int. |
| */ |
| public void testLongValueNegative1() { |
| byte aBytes[] = {12, -1, 100, -2, -76, -128, 45, 91, 3}; |
| long result = -43630045168837885L; |
| long aNumber = new BigInteger(aBytes).longValue(); |
| assertEquals(result, aNumber); |
| } |
| |
| /** |
| * Convert a number to a negative long value The number fits in a long. |
| */ |
| public void testLongValueNegative2() { |
| byte aBytes[] = {-12, 56, 100, 45, -101, 45, 98}; |
| long result = -3315696807498398L; |
| long aNumber = new BigInteger(aBytes).longValue(); |
| assertEquals(result, aNumber); |
| } |
| |
| /** |
| * Convert a BigInteger to a positive long value The BigInteger is longer than |
| * int. |
| */ |
| public void testLongValuePositive1() { |
| byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, 120, -34, -12, 45, 98}; |
| long result = 3268209772258930018L; |
| long aNumber = new BigInteger(aBytes).longValue(); |
| assertEquals(result, aNumber); |
| } |
| |
| /** |
| * Convert a number to a positive long value The number fits in a long. |
| */ |
| public void testLongValuePositive2() { |
| byte aBytes[] = {12, 56, 100, 18, -105, 34, -18, 45}; |
| long result = 880563758158769709L; |
| long aNumber = new BigInteger(aBytes).longValue(); |
| assertEquals(result, aNumber); |
| } |
| |
| public void testLongValueExact() { |
| assertEquals(-1, BigInteger.valueOf(-1).longValueExact()); |
| assertEquals(0, BigInteger.valueOf(0).longValueExact()); |
| assertEquals(1, BigInteger.valueOf(1).longValueExact()); |
| assertEquals(Long.MAX_VALUE, BigInteger.valueOf(Long.MAX_VALUE).longValueExact()); |
| assertEquals(Long.MIN_VALUE, BigInteger.valueOf(Long.MIN_VALUE).longValueExact()); |
| |
| try { |
| BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE).longValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| try { |
| BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE).longValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| } |
| |
| public void testShortValueExact() { |
| assertEquals(-1, BigInteger.valueOf(-1).shortValueExact()); |
| assertEquals(0, BigInteger.valueOf(0).shortValueExact()); |
| assertEquals(1, BigInteger.valueOf(1).shortValueExact()); |
| assertEquals(Short.MAX_VALUE, BigInteger.valueOf(Short.MAX_VALUE).shortValueExact()); |
| assertEquals(Short.MIN_VALUE, BigInteger.valueOf(Short.MIN_VALUE).shortValueExact()); |
| |
| try { |
| BigInteger.valueOf(Short.MAX_VALUE + 1).shortValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| try { |
| BigInteger.valueOf(Short.MIN_VALUE - 1).shortValueExact(); |
| fail("overflow expected"); |
| } catch (Exception expected) { |
| } |
| } |
| |
| /** |
| * valueOf (long val): convert Integer.MAX_VALUE to a BigInteger. |
| */ |
| public void testValueOfIntegerMax() { |
| long longVal = Integer.MAX_VALUE; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {127, -1, -1, -1}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert Integer.MIN_VALUE to a BigInteger. |
| */ |
| public void testValueOfIntegerMin() { |
| long longVal = Integer.MIN_VALUE; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {-128, 0, 0, 0}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert Long.MAX_VALUE to a BigInteger. |
| */ |
| public void testValueOfLongMax() { |
| long longVal = Long.MAX_VALUE; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {127, -1, -1, -1, -1, -1, -1, -1}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert Long.MIN_VALUE to a BigInteger. |
| */ |
| public void testValueOfLongMin() { |
| long longVal = Long.MIN_VALUE; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {-128, 0, 0, 0, 0, 0, 0, 0}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a negative long value to a BigInteger. |
| */ |
| public void testValueOfLongNegative1() { |
| long longVal = -268209772258930018L; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {-4, 71, 32, -94, 23, 55, -46, -98}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a negative long value to a BigInteger. The long |
| * value fits in integer. |
| */ |
| public void testValueOfLongNegative2() { |
| long longVal = -58930018L; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {-4, 124, -52, -98}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a positive long value to a BigInteger. |
| */ |
| public void testValueOfLongPositive1() { |
| long longVal = 268209772258930018L; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {3, -72, -33, 93, -24, -56, 45, 98}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a positive long value to a BigInteger. The long |
| * value fits in integer. |
| */ |
| public void testValueOfLongPositive2() { |
| long longVal = 58930018L; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {3, -125, 51, 98}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a zero long value to a BigInteger. |
| */ |
| public void testValueOfLongZero() { |
| long longVal = 0L; |
| BigInteger aNumber = BigInteger.valueOf(longVal); |
| byte rBytes[] = {0}; |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = aNumber.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertEquals("Byte " + i, rBytes[i], resBytes[i]); |
| } |
| assertEquals("incorrect sign", 0, aNumber.signum()); |
| } |
| } |