| /* |
| * 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. |
| */ |
| /** |
| * @author Elena Semukhina |
| * @version $Revision$ |
| */ |
| |
| package org.apache.harmony.math.tests.java.math; |
| |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| |
| import java.math.BigInteger; |
| |
| import junit.framework.TestCase; |
| @TestTargetClass(BigInteger.class) |
| /** |
| * Class: java.math.BigInteger |
| * Methods: intValue, longValue, toByteArray(), valueOf(long val), |
| * floatValue(), doubleValue() |
| */ |
| public class BigIntegerConvertTest extends TestCase { |
| /** |
| * Return the double value of ZERO. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| public void testDoubleValueZero() { |
| String a = "0"; |
| double result = 0.0; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a double value. |
| * The number's length is less than 64 bits. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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]. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| public void testDoubleValuePositive2() { |
| 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 less than 64 bits. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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]. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| public void testDoubleValueNegative2() { |
| String a = "-2746723894572364578265426346273456972"; |
| double result = -2.7467238945723645E36; |
| double aNumber = new BigInteger(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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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); |
| } |
| /** |
| * Convert a positive number to a double value. |
| * Rounding is NOT needed. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| * Rounding is NOT needed. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| * The exponent is 1023 and the mantissa is all 1s. |
| * The rounding bit is 0. |
| * The result is Double.MAX_VALUE. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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 negative number to a double value. |
| * The exponent is 1023 and the mantissa is all 1s. |
| * The result is -Double.MAX_VALUE. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| * The exponent is 1023 and the mantissa is all 1s. |
| * The rounding bit is 1. |
| * The result is Double.POSITIVE_INFINITY. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| public void testDoubleValuePositiveInfinity2() { |
| String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; |
| double aNumber = new BigInteger(a).doubleValue(); |
| assertTrue(aNumber == Double.POSITIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a negative number to a double value. |
| * The number's bit length is greater than 1024. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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 0s |
| * but the 54th bit (implicit) is 1. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for doubleValue method.", |
| method = "doubleValue", |
| args = {} |
| ) |
| 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); |
| } |
| |
| /** |
| * Return the float value of ZERO. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValueZero() { |
| String a = "0"; |
| float result = 0.0f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a float value. |
| * The number's length is less than 32 bits. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValuePositive1() { |
| String a = "27467238"; |
| float result = 2.7467238E7f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a float value. |
| * The number's bit length is inside [32, 127]. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValuePositive2() { |
| String a = "27467238945723645782"; |
| float result = 2.7467239E19f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a negative number to a float value. |
| * The number's bit length is less than 32 bits. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValueNegative1() { |
| String a = "-27467238"; |
| float result = -2.7467238E7f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a negative number to a doufloatble value. |
| * The number's bit length is inside [63, 1024]. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValueNegative2() { |
| String a = "-27467238945723645782"; |
| float result = -2.7467239E19f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| /** |
| * Convert a positive number to a float value. |
| * Rounding is NOT needed. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a float value. |
| * Rounding is needed. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a float value. |
| * Rounding is NOT needed. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive number to a float value. |
| * The exponent is 1023 and the mantissa is all 1s. |
| * The rounding bit is 0. |
| * The result is Float.MAX_VALUE. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValuePosMaxValue() { |
| byte[] a = {0, -1, -1, -1, 0, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1}; |
| int aSign = 1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertTrue(aNumber == Float.MAX_VALUE); |
| } |
| |
| /** |
| * Convert a negative number to a float value. |
| * The exponent is 1023 and the mantissa is all 1s. |
| * The rounding bit is 0. |
| * The result is -Float.MAX_VALUE. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValueNegMaxValue() { |
| byte[] a = {0, -1, -1, -1, 0, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1}; |
| int aSign = -1; |
| float aNumber = new BigInteger(aSign, a).floatValue(); |
| assertTrue(aNumber == -Float.MAX_VALUE); |
| } |
| |
| /** |
| * 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == Float.POSITIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a positive number to a float value. |
| * The number's bit length is greater than 127. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValuePositiveInfinity2() { |
| String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == Float.POSITIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a negative number to a float value. |
| * The number's bit length is greater than 127. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValueNegativeInfinity1() { |
| String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == Float.NEGATIVE_INFINITY); |
| } |
| |
| /** |
| * 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == Float.NEGATIVE_INFINITY); |
| } |
| |
| /** |
| * 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == Float.NEGATIVE_INFINITY); |
| } |
| |
| /** |
| * Convert a negative number to a float value. |
| * The number's bit length is less than 32 bits. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for floatValue method.", |
| method = "floatValue", |
| args = {} |
| ) |
| public void testFloatValueBug2482() { |
| String a = "2147483649"; |
| float result = 2.14748365E9f; |
| float aNumber = new BigInteger(a).floatValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a positive BigInteger to an integer value. |
| * The low digit is positive |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for intValue method.", |
| method = "intValue", |
| args = {} |
| ) |
| public void testIntValuePositive1() { |
| byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3}; |
| int resInt = 1496144643; |
| int aNumber = new BigInteger(aBytes).intValue(); |
| assertTrue(aNumber == resInt); |
| } |
| |
| /** |
| * Convert a positive BigInteger to an integer value. |
| * The low digit is positive |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for intValue method.", |
| method = "intValue", |
| args = {} |
| ) |
| public void testIntValuePositive2() { |
| byte aBytes[] = {12, 56, 100}; |
| int resInt = 800868; |
| int aNumber = new BigInteger(aBytes).intValue(); |
| assertTrue(aNumber == resInt); |
| } |
| |
| /** |
| * Convert a positive BigInteger to an integer value. |
| * The low digit is negative. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for intValue method.", |
| method = "intValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == resInt); |
| } |
| |
| /** |
| * Convert a negative BigInteger to an integer value. |
| * The low digit is negative. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for intValue method.", |
| method = "intValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == resInt); |
| } |
| |
| /** |
| * Convert a negative BigInteger to an integer value. |
| * The low digit is negative. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for intValue method.", |
| method = "intValue", |
| args = {} |
| ) |
| public void testIntValueNegative2() { |
| byte aBytes[] = {-12, 56, 100}; |
| int result = -771996; |
| int aNumber = new BigInteger(aBytes).intValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a negative BigInteger to an integer value. |
| * The low digit is positive. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for intValue method.", |
| method = "intValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == resInt); |
| } |
| |
| /** |
| * Convert a BigInteger to a positive long value |
| * The BigInteger is longer than int. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for longValue method.", |
| method = "longValue", |
| args = {} |
| ) |
| 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(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a number to a positive long value |
| * The number fits in a long. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for longValue method.", |
| method = "longValue", |
| args = {} |
| ) |
| public void testLongValuePositive2() { |
| byte aBytes[] = {12, 56, 100, 18, -105, 34, -18, 45}; |
| long result = 880563758158769709L; |
| long aNumber = new BigInteger(aBytes).longValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a number to a negative long value |
| * The BigInteger is longer than int. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for longValue method.", |
| method = "longValue", |
| args = {} |
| ) |
| public void testLongValueNegative1() { |
| byte aBytes[] = {12, -1, 100, -2, -76, -128, 45, 91, 3}; |
| long result = -43630045168837885L; |
| long aNumber = new BigInteger(aBytes).longValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * Convert a number to a negative long value |
| * The number fits in a long. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for longValue method.", |
| method = "longValue", |
| args = {} |
| ) |
| public void testLongValueNegative2() { |
| byte aBytes[] = {-12, 56, 100, 45, -101, 45, 98}; |
| long result = -3315696807498398L; |
| long aNumber = new BigInteger(aBytes).longValue(); |
| assertTrue(aNumber == result); |
| } |
| |
| /** |
| * valueOf (long val): convert Integer.MAX_VALUE to a BigInteger. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert Integer.MIN_VALUE to a BigInteger. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert Long.MAX_VALUE to a BigInteger. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert Long.MIN_VALUE to a BigInteger. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a positive long value to a BigInteger. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a positive long value to a BigInteger. |
| * The long value fits in integer. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a negative long value to a BigInteger. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| |
| /** |
| * valueOf (long val): convert a negative long value to a BigInteger. |
| * The long value fits in integer. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, aNumber.signum()); |
| } |
| /** |
| * valueOf (long val): convert a zero long value to a BigInteger. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "This is a complete subset of tests for valueOf method.", |
| method = "valueOf", |
| args = {long.class} |
| ) |
| 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++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 0, aNumber.signum()); |
| } |
| } |