1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 /** 18 * @author Elena Semukhina 19 */ 20 21 package org.apache.harmony.tests.java.math; 22 23 import junit.framework.TestCase; 24 import java.math.BigInteger; 25 26 /** 27 * Class: java.math.BigInteger 28 * Methods: intValue, longValue, toByteArray(), valueOf(long val), 29 * floatValue(), doubleValue() 30 */ 31 public class BigIntegerConvertTest extends TestCase { 32 /** 33 * Return the double value of ZERO. 34 */ 35 public void testDoubleValueZero() { 36 String a = "0"; 37 double result = 0.0; 38 double aNumber = new BigInteger(a).doubleValue(); 39 assertTrue(aNumber == result); 40 } 41 42 /** 43 * Convert a positive number to a double value. 44 * The number's length is less than 64 bits. 45 */ 46 public void testDoubleValuePositive1() { 47 String a = "27467238945"; 48 double result = 2.7467238945E10; 49 double aNumber = new BigInteger(a).doubleValue(); 50 assertTrue(aNumber == result); 51 } 52 53 /** 54 * Convert a positive number to a double value. 55 * The number's bit length is inside [63, 1024]. 56 */ 57 public void testDoubleValuePositive2() { 58 String a = "2746723894572364578265426346273456972"; 59 double result = 2.7467238945723645E36; 60 double aNumber = new BigInteger(a).doubleValue(); 61 assertTrue(aNumber == result); 62 } 63 64 /** 65 * Convert a negative number to a double value. 66 * The number's bit length is less than 64 bits. 67 */ 68 public void testDoubleValueNegative1() { 69 String a = "-27467238945"; 70 double result = -2.7467238945E10; 71 double aNumber = new BigInteger(a).doubleValue(); 72 assertTrue(aNumber == result); 73 } 74 75 /** 76 * Convert a negative number to a double value. 77 * The number's bit length is inside [63, 1024]. 78 */ 79 public void testDoubleValueNegative2() { 80 String a = "-2746723894572364578265426346273456972"; 81 double result = -2.7467238945723645E36; 82 double aNumber = new BigInteger(a).doubleValue(); 83 assertTrue(aNumber == result); 84 } 85 86 /** 87 * Convert a positive number to a double value. 88 * Rounding is needed. 89 * The rounding bit is 1 and the next bit to the left is 1. 90 */ 91 public void testDoubleValuePosRounded1() { 92 byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; 93 int aSign = 1; 94 double result = 1.54747264387948E26; 95 double aNumber = new BigInteger(aSign, a).doubleValue(); 96 assertTrue(aNumber == result); 97 } 98 99 /** 100 * Convert a positive number to a double value. 101 * Rounding is needed. 102 * The rounding bit is 1 and the next bit to the left is 0 103 * but some of dropped bits are 1s. 104 */ 105 public void testDoubleValuePosRounded2() { 106 byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5}; 107 int aSign = 1; 108 double result = 1.547472643879479E26; 109 double aNumber = new BigInteger(aSign, a).doubleValue(); 110 assertTrue(aNumber == result); 111 } 112 /** 113 * Convert a positive number to a double value. 114 * Rounding is NOT needed. 115 */ 116 public void testDoubleValuePosNotRounded() { 117 byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5}; 118 int aSign = 1; 119 double result = 1.5474726438794828E26; 120 double aNumber = new BigInteger(aSign, a).doubleValue(); 121 assertTrue(aNumber == result); 122 } 123 124 /** 125 * Convert a positive number to a double value. 126 * Rounding is needed. 127 */ 128 public void testDoubleValueNegRounded1() { 129 byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; 130 int aSign = -1; 131 double result = -1.54747264387948E26; 132 double aNumber = new BigInteger(aSign, a).doubleValue(); 133 assertTrue(aNumber == result); 134 } 135 136 /** 137 * Convert a positive number to a double value. 138 * Rounding is needed. 139 * The rounding bit is 1 and the next bit to the left is 0 140 * but some of dropped bits are 1s. 141 */ 142 public void testDoubleValueNegRounded2() { 143 byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5}; 144 int aSign = -1; 145 double result = -1.547472643879479E26; 146 double aNumber = new BigInteger(aSign, a).doubleValue(); 147 assertTrue(aNumber == result); 148 } 149 150 /** 151 * Convert a positive number to a double value. 152 * Rounding is NOT needed. 153 */ 154 public void testDoubleValueNegNotRounded() { 155 byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5}; 156 int aSign = -1; 157 double result = -1.5474726438794828E26; 158 double aNumber = new BigInteger(aSign, a).doubleValue(); 159 assertTrue(aNumber == result); 160 } 161 162 /** 163 * Convert a positive number to a double value. 164 * The exponent is 1023 and the mantissa is all 1s. 165 * The rounding bit is 0. 166 * The result is Double.MAX_VALUE. 167 */ 168 public void testDoubleValuePosMaxValue() { 169 byte[] a = {0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1, 170 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 171 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 172 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 173 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 174 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 176 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 177 }; 178 int aSign = 1; 179 double aNumber = new BigInteger(aSign, a).doubleValue(); 180 assertTrue(aNumber == Double.MAX_VALUE); 181 } 182 183 /** 184 * Convert a negative number to a double value. 185 * The exponent is 1023 and the mantissa is all 1s. 186 * The result is -Double.MAX_VALUE. 187 */ 188 public void testDoubleValueNegMaxValue() { 189 byte[] a = {0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1, 190 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 191 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 192 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 193 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 194 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 195 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 196 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 197 }; 198 int aSign = -1; 199 double aNumber = new BigInteger(aSign, a).doubleValue(); 200 assertTrue(aNumber == -Double.MAX_VALUE); 201 } 202 203 /** 204 * Convert a positive number to a double value. 205 * The exponent is 1023 and the mantissa is all 1s. 206 * The rounding bit is 1. 207 * The result is Double.POSITIVE_INFINITY. 208 */ 209 public void testDoubleValuePositiveInfinity1() { 210 byte[] a = {-1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 212 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 213 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 214 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 216 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 218 }; 219 int aSign = 1; 220 double aNumber = new BigInteger(aSign, a).doubleValue(); 221 assertTrue(aNumber == Double.POSITIVE_INFINITY); 222 } 223 224 /** 225 * Convert a positive number to a double value. 226 * The number's bit length is greater than 1024. 227 */ 228 public void testDoubleValuePositiveInfinity2() { 229 String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; 230 double aNumber = new BigInteger(a).doubleValue(); 231 assertTrue(aNumber == Double.POSITIVE_INFINITY); 232 } 233 234 /** 235 * Convert a negative number to a double value. 236 * The number's bit length is greater than 1024. 237 */ 238 public void testDoubleValueNegativeInfinity1() { 239 String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; 240 double aNumber = new BigInteger(a).doubleValue(); 241 assertTrue(aNumber == Double.NEGATIVE_INFINITY); 242 } 243 244 /** 245 * Convert a negative number to a double value. 246 * The exponent is 1023 and the mantissa is all 0s. 247 * The rounding bit is 0. 248 * The result is Double.NEGATIVE_INFINITY. 249 */ 250 public void testDoubleValueNegativeInfinity2() { 251 byte[] a = {-1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 259 }; 260 int aSign = -1; 261 double aNumber = new BigInteger(aSign, a).doubleValue(); 262 assertTrue(aNumber == Double.NEGATIVE_INFINITY); 263 } 264 265 /** 266 * Convert a positive number to a double value. 267 * The exponent is 1023 and the mantissa is all 0s 268 * but the 54th bit (implicit) is 1. 269 */ 270 public void testDoubleValuePosMantissaIsZero() { 271 byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 272 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 273 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 274 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 275 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 276 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 277 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 278 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 279 }; 280 int aSign = 1; 281 double result = 8.98846567431158E307; 282 double aNumber = new BigInteger(aSign, a).doubleValue(); 283 assertTrue(aNumber == result); 284 } 285 286 /** 287 * Convert a positive number to a double value. 288 * The exponent is 1023 and the mantissa is all 0s 289 * but the 54th bit (implicit) is 1. 290 */ 291 public void testDoubleValueNegMantissaIsZero() { 292 byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 293 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 294 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 295 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 296 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 297 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 298 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 299 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 300 }; 301 int aSign = -1; 302 double aNumber = new BigInteger(aSign, a).doubleValue(); 303 assertTrue(aNumber == -8.98846567431158E307); 304 } 305 306 /** 307 * Return the float value of ZERO. 308 */ 309 public void testFloatValueZero() { 310 String a = "0"; 311 float result = 0.0f; 312 float aNumber = new BigInteger(a).floatValue(); 313 assertTrue(aNumber == result); 314 } 315 316 /** 317 * Convert a positive number to a float value. 318 * The number's length is less than 32 bits. 319 */ 320 public void testFloatValuePositive1() { 321 String a = "27467238"; 322 float result = 2.7467238E7f; 323 float aNumber = new BigInteger(a).floatValue(); 324 assertTrue(aNumber == result); 325 } 326 327 /** 328 * Convert a positive number to a float value. 329 * The number's bit length is inside [32, 127]. 330 */ 331 public void testFloatValuePositive2() { 332 String a = "27467238945723645782"; 333 float result = 2.7467239E19f; 334 float aNumber = new BigInteger(a).floatValue(); 335 assertTrue(aNumber == result); 336 } 337 338 /** 339 * Convert a negative number to a float value. 340 * The number's bit length is less than 32 bits. 341 */ 342 public void testFloatValueNegative1() { 343 String a = "-27467238"; 344 float result = -2.7467238E7f; 345 float aNumber = new BigInteger(a).floatValue(); 346 assertTrue(aNumber == result); 347 } 348 349 /** 350 * Convert a negative number to a doufloatble value. 351 * The number's bit length is inside [63, 1024]. 352 */ 353 public void testFloatValueNegative2() { 354 String a = "-27467238945723645782"; 355 float result = -2.7467239E19f; 356 float aNumber = new BigInteger(a).floatValue(); 357 assertTrue(aNumber == result); 358 } 359 360 /** 361 * Convert a positive number to a float value. 362 * Rounding is needed. 363 * The rounding bit is 1 and the next bit to the left is 1. 364 */ 365 public void testFloatValuePosRounded1() { 366 byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5}; 367 int aSign = 1; 368 float result = 1.5475195E26f; 369 float aNumber = new BigInteger(aSign, a).floatValue(); 370 assertTrue(aNumber == result); 371 } 372 373 /** 374 * Convert a positive number to a float value. 375 * Rounding is needed. 376 * The rounding bit is 1 and the next bit to the left is 0 377 * but some of dropped bits are 1s. 378 */ 379 public void testFloatValuePosRounded2() { 380 byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5}; 381 int aSign = 1; 382 float result = 1.5474728E26f; 383 float aNumber = new BigInteger(aSign, a).floatValue(); 384 assertTrue(aNumber == result); 385 } 386 /** 387 * Convert a positive number to a float value. 388 * Rounding is NOT needed. 389 */ 390 public void testFloatValuePosNotRounded() { 391 byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; 392 int aSign = 1; 393 float result = 1.5474726E26f; 394 float aNumber = new BigInteger(aSign, a).floatValue(); 395 assertTrue(aNumber == result); 396 } 397 398 /** 399 * Convert a positive number to a float value. 400 * Rounding is needed. 401 */ 402 public void testFloatValueNegRounded1() { 403 byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5}; 404 int aSign = -1; 405 float result = -1.5475195E26f; 406 float aNumber = new BigInteger(aSign, a).floatValue(); 407 assertTrue(aNumber == result); 408 } 409 410 /** 411 * Convert a positive number to a float value. 412 * Rounding is needed. 413 * The rounding bit is 1 and the next bit to the left is 0 414 * but some of dropped bits are 1s. 415 */ 416 public void testFloatValueNegRounded2() { 417 byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5}; 418 int aSign = -1; 419 float result = -1.5474728E26f; 420 float aNumber = new BigInteger(aSign, a).floatValue(); 421 assertTrue(aNumber == result); 422 } 423 424 /** 425 * Convert a positive number to a float value. 426 * Rounding is NOT needed. 427 */ 428 public void testFloatValueNegNotRounded() { 429 byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5}; 430 int aSign = -1; 431 float result = -1.5474726E26f; 432 float aNumber = new BigInteger(aSign, a).floatValue(); 433 assertTrue(aNumber == result); 434 } 435 436 /** 437 * Convert a positive number to a float value. 438 * The exponent is 1023 and the mantissa is all 1s. 439 * The rounding bit is 0. 440 * The result is Float.MAX_VALUE. 441 */ 442 public void testFloatValuePosMaxValue() { 443 byte[] a = {0, -1, -1, -1, 0, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1}; 444 int aSign = 1; 445 float aNumber = new BigInteger(aSign, a).floatValue(); 446 assertTrue(aNumber == Float.MAX_VALUE); 447 } 448 449 /** 450 * Convert a negative number to a float value. 451 * The exponent is 1023 and the mantissa is all 1s. 452 * The rounding bit is 0. 453 * The result is -Float.MAX_VALUE. 454 */ 455 public void testFloatValueNegMaxValue() { 456 byte[] a = {0, -1, -1, -1, 0, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1}; 457 int aSign = -1; 458 float aNumber = new BigInteger(aSign, a).floatValue(); 459 assertTrue(aNumber == -Float.MAX_VALUE); 460 } 461 462 /** 463 * Convert a positive number to a float value. 464 * The exponent is 1023 and the mantissa is all 1s. 465 * The rounding bit is 1. 466 * The result is Float.POSITIVE_INFINITY. 467 */ 468 public void testFloatValuePositiveInfinity1() { 469 byte[] a = {0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; 470 int aSign = 1; 471 float aNumber = new BigInteger(aSign, a).floatValue(); 472 assertTrue(aNumber == Float.POSITIVE_INFINITY); 473 } 474 475 /** 476 * Convert a positive number to a float value. 477 * The number's bit length is greater than 127. 478 */ 479 public void testFloatValuePositiveInfinity2() { 480 String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; 481 float aNumber = new BigInteger(a).floatValue(); 482 assertTrue(aNumber == Float.POSITIVE_INFINITY); 483 } 484 485 /** 486 * Convert a negative number to a float value. 487 * The number's bit length is greater than 127. 488 */ 489 public void testFloatValueNegativeInfinity1() { 490 String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863"; 491 float aNumber = new BigInteger(a).floatValue(); 492 assertTrue(aNumber == Float.NEGATIVE_INFINITY); 493 } 494 495 /** 496 * Convert a negative number to a float value. 497 * The exponent is 1023 and the mantissa is all 0s. 498 * The rounding bit is 0. 499 * The result is Float.NEGATIVE_INFINITY. 500 */ 501 public void testFloatValueNegativeInfinity2() { 502 byte[] a = {0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; 503 int aSign = -1; 504 float aNumber = new BigInteger(aSign, a).floatValue(); 505 assertTrue(aNumber == Float.NEGATIVE_INFINITY); 506 } 507 508 /** 509 * Convert a positive number to a float value. 510 * The exponent is 1023 and the mantissa is all 0s 511 * but the 54th bit (implicit) is 1. 512 */ 513 public void testFloatValuePosMantissaIsZero() { 514 byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 515 int aSign = 1; 516 float result = 1.7014118E38f; 517 float aNumber = new BigInteger(aSign, a).floatValue(); 518 assertTrue(aNumber == result); 519 } 520 521 /** 522 * Convert a positive number to a double value. 523 * The exponent is 1023 and the mantissa is all 0s 524 * but the 54th bit (implicit) is 1. 525 */ 526 public void testFloatValueNegMantissaIsZero() { 527 byte[] a = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 528 int aSign = -1; 529 float aNumber = new BigInteger(aSign, a).floatValue(); 530 assertTrue(aNumber == Float.NEGATIVE_INFINITY); 531 } 532 533 /** 534 * Convert a negative number to a float value. 535 * The number's bit length is less than 32 bits. 536 */ 537 public void testFloatValueBug2482() { 538 String a = "2147483649"; 539 float result = 2.14748365E9f; 540 float aNumber = new BigInteger(a).floatValue(); 541 assertTrue(aNumber == result); 542 } 543 544 /** 545 * Convert a positive BigInteger to an integer value. 546 * The low digit is positive 547 */ 548 public void testIntValuePositive1() { 549 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3}; 550 int resInt = 1496144643; 551 int aNumber = new BigInteger(aBytes).intValue(); 552 assertTrue(aNumber == resInt); 553 } 554 555 /** 556 * Convert a positive BigInteger to an integer value. 557 * The low digit is positive 558 */ 559 public void testIntValuePositive2() { 560 byte aBytes[] = {12, 56, 100}; 561 int resInt = 800868; 562 int aNumber = new BigInteger(aBytes).intValue(); 563 assertTrue(aNumber == resInt); 564 } 565 566 /** 567 * Convert a positive BigInteger to an integer value. 568 * The low digit is negative. 569 */ 570 public void testIntValuePositive3() { 571 byte aBytes[] = {56, 13, 78, -12, -5, 56, 100}; 572 int sign = 1; 573 int resInt = -184862620; 574 int aNumber = new BigInteger(sign, aBytes).intValue(); 575 assertTrue(aNumber == resInt); 576 } 577 578 /** 579 * Convert a negative BigInteger to an integer value. 580 * The low digit is negative. 581 */ 582 public void testIntValueNegative1() { 583 byte aBytes[] = {12, 56, 100, -2, -76, -128, 45, 91, 3}; 584 int sign = -1; 585 int resInt = 2144511229; 586 int aNumber = new BigInteger(sign, aBytes).intValue(); 587 assertTrue(aNumber == resInt); 588 } 589 590 /** 591 * Convert a negative BigInteger to an integer value. 592 * The low digit is negative. 593 */ 594 public void testIntValueNegative2() { 595 byte aBytes[] = {-12, 56, 100}; 596 int result = -771996; 597 int aNumber = new BigInteger(aBytes).intValue(); 598 assertTrue(aNumber == result); 599 } 600 601 /** 602 * Convert a negative BigInteger to an integer value. 603 * The low digit is positive. 604 */ 605 public void testIntValueNegative3() { 606 byte aBytes[] = {12, 56, 100, -2, -76, 127, 45, 91, 3}; 607 int sign = -1; 608 int resInt = -2133678851; 609 int aNumber = new BigInteger(sign, aBytes).intValue(); 610 assertTrue(aNumber == resInt); 611 } 612 613 /** 614 * Convert a BigInteger to a positive long value 615 * The BigInteger is longer than int. 616 */ 617 public void testLongValuePositive1() { 618 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, 120, -34, -12, 45, 98}; 619 long result = 3268209772258930018L; 620 long aNumber = new BigInteger(aBytes).longValue(); 621 assertTrue(aNumber == result); 622 } 623 624 /** 625 * Convert a number to a positive long value 626 * The number fits in a long. 627 */ 628 public void testLongValuePositive2() { 629 byte aBytes[] = {12, 56, 100, 18, -105, 34, -18, 45}; 630 long result = 880563758158769709L; 631 long aNumber = new BigInteger(aBytes).longValue(); 632 assertTrue(aNumber == result); 633 } 634 635 /** 636 * Convert a number to a negative long value 637 * The BigInteger is longer than int. 638 */ 639 public void testLongValueNegative1() { 640 byte aBytes[] = {12, -1, 100, -2, -76, -128, 45, 91, 3}; 641 long result = -43630045168837885L; 642 long aNumber = new BigInteger(aBytes).longValue(); 643 assertTrue(aNumber == result); 644 } 645 646 /** 647 * Convert a number to a negative long value 648 * The number fits in a long. 649 */ 650 public void testLongValueNegative2() { 651 byte aBytes[] = {-12, 56, 100, 45, -101, 45, 98}; 652 long result = -3315696807498398L; 653 long aNumber = new BigInteger(aBytes).longValue(); 654 assertTrue(aNumber == result); 655 } 656 657 /** 658 * valueOf (long val): convert Integer.MAX_VALUE to a BigInteger. 659 */ 660 public void testValueOfIntegerMax() { 661 long longVal = Integer.MAX_VALUE; 662 BigInteger aNumber = BigInteger.valueOf(longVal); 663 byte rBytes[] = {127, -1, -1, -1}; 664 byte resBytes[] = new byte[rBytes.length]; 665 resBytes = aNumber.toByteArray(); 666 for(int i = 0; i < resBytes.length; i++) { 667 assertTrue(resBytes[i] == rBytes[i]); 668 } 669 assertEquals("incorrect sign", 1, aNumber.signum()); 670 } 671 672 /** 673 * valueOf (long val): convert Integer.MIN_VALUE to a BigInteger. 674 */ 675 public void testValueOfIntegerMin() { 676 long longVal = Integer.MIN_VALUE; 677 BigInteger aNumber = BigInteger.valueOf(longVal); 678 byte rBytes[] = {-128, 0, 0, 0}; 679 byte resBytes[] = new byte[rBytes.length]; 680 resBytes = aNumber.toByteArray(); 681 for(int i = 0; i < resBytes.length; i++) { 682 assertTrue(resBytes[i] == rBytes[i]); 683 } 684 assertEquals("incorrect sign", -1, aNumber.signum()); 685 } 686 687 /** 688 * valueOf (long val): convert Long.MAX_VALUE to a BigInteger. 689 */ 690 public void testValueOfLongMax() { 691 long longVal = Long.MAX_VALUE; 692 BigInteger aNumber = BigInteger.valueOf(longVal); 693 byte rBytes[] = {127, -1, -1, -1, -1, -1, -1, -1}; 694 byte resBytes[] = new byte[rBytes.length]; 695 resBytes = aNumber.toByteArray(); 696 for(int i = 0; i < resBytes.length; i++) { 697 assertTrue(resBytes[i] == rBytes[i]); 698 } 699 assertEquals("incorrect sign", 1, aNumber.signum()); 700 } 701 702 /** 703 * valueOf (long val): convert Long.MIN_VALUE to a BigInteger. 704 */ 705 public void testValueOfLongMin() { 706 long longVal = Long.MIN_VALUE; 707 BigInteger aNumber = BigInteger.valueOf(longVal); 708 byte rBytes[] = {-128, 0, 0, 0, 0, 0, 0, 0}; 709 byte resBytes[] = new byte[rBytes.length]; 710 resBytes = aNumber.toByteArray(); 711 for(int i = 0; i < resBytes.length; i++) { 712 assertTrue(resBytes[i] == rBytes[i]); 713 } 714 assertEquals("incorrect sign", -1, aNumber.signum()); 715 } 716 717 /** 718 * valueOf (long val): convert a positive long value to a BigInteger. 719 */ 720 public void testValueOfLongPositive1() { 721 long longVal = 268209772258930018L; 722 BigInteger aNumber = BigInteger.valueOf(longVal); 723 byte rBytes[] = {3, -72, -33, 93, -24, -56, 45, 98}; 724 byte resBytes[] = new byte[rBytes.length]; 725 resBytes = aNumber.toByteArray(); 726 for(int i = 0; i < resBytes.length; i++) { 727 assertTrue(resBytes[i] == rBytes[i]); 728 } 729 assertEquals("incorrect sign", 1, aNumber.signum()); 730 } 731 732 /** 733 * valueOf (long val): convert a positive long value to a BigInteger. 734 * The long value fits in integer. 735 */ 736 public void testValueOfLongPositive2() { 737 long longVal = 58930018L; 738 BigInteger aNumber = BigInteger.valueOf(longVal); 739 byte rBytes[] = {3, -125, 51, 98}; 740 byte resBytes[] = new byte[rBytes.length]; 741 resBytes = aNumber.toByteArray(); 742 for(int i = 0; i < resBytes.length; i++) { 743 assertTrue(resBytes[i] == rBytes[i]); 744 } 745 assertEquals("incorrect sign", 1, aNumber.signum()); 746 } 747 748 /** 749 * valueOf (long val): convert a negative long value to a BigInteger. 750 */ 751 public void testValueOfLongNegative1() { 752 long longVal = -268209772258930018L; 753 BigInteger aNumber = BigInteger.valueOf(longVal); 754 byte rBytes[] = {-4, 71, 32, -94, 23, 55, -46, -98}; 755 byte resBytes[] = new byte[rBytes.length]; 756 resBytes = aNumber.toByteArray(); 757 for(int i = 0; i < resBytes.length; i++) { 758 assertTrue(resBytes[i] == rBytes[i]); 759 } 760 assertEquals("incorrect sign", -1, aNumber.signum()); 761 } 762 763 /** 764 * valueOf (long val): convert a negative long value to a BigInteger. 765 * The long value fits in integer. 766 */ 767 public void testValueOfLongNegative2() { 768 long longVal = -58930018L; 769 BigInteger aNumber = BigInteger.valueOf(longVal); 770 byte rBytes[] = {-4, 124, -52, -98}; 771 byte resBytes[] = new byte[rBytes.length]; 772 resBytes = aNumber.toByteArray(); 773 for(int i = 0; i < resBytes.length; i++) { 774 assertTrue(resBytes[i] == rBytes[i]); 775 } 776 assertEquals("incorrect sign", -1, aNumber.signum()); 777 } 778 /** 779 * valueOf (long val): convert a zero long value to a BigInteger. 780 */ 781 public void testValueOfLongZero() { 782 long longVal = 0L; 783 BigInteger aNumber = BigInteger.valueOf(longVal); 784 byte rBytes[] = {0}; 785 byte resBytes[] = new byte[rBytes.length]; 786 resBytes = aNumber.toByteArray(); 787 for(int i = 0; i < resBytes.length; i++) { 788 assertTrue(resBytes[i] == rBytes[i]); 789 } 790 assertEquals("incorrect sign", 0, aNumber.signum()); 791 } 792 } 793
