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: abs, compareTo, equals, max, min, negate, signum 29 */ 30 public class BigIntegerCompareTest extends TestCase { 31 /** 32 * abs() for a positive number 33 */ 34 public void testAbsPositive() { 35 byte aBytes[] = {1, 2, 3, 4, 5, 6, 7}; 36 int aSign = 1; 37 byte rBytes[] = {1, 2, 3, 4, 5, 6, 7}; 38 BigInteger aNumber = new BigInteger(aSign, aBytes); 39 BigInteger result = aNumber.abs(); 40 byte resBytes[] = new byte[rBytes.length]; 41 resBytes = result.toByteArray(); 42 for(int i = 0; i < resBytes.length; i++) { 43 assertTrue(resBytes[i] == rBytes[i]); 44 } 45 assertEquals("incorrect sign", 1, result.signum()); 46 } 47 48 /** 49 * abs() for a negative number 50 */ 51 public void testAbsNegative() { 52 byte aBytes[] = {1, 2, 3, 4, 5, 6, 7}; 53 int aSign = -1; 54 byte rBytes[] = {1, 2, 3, 4, 5, 6, 7}; 55 BigInteger aNumber = new BigInteger(aSign, aBytes); 56 BigInteger result = aNumber.abs(); 57 byte resBytes[] = new byte[rBytes.length]; 58 resBytes = result.toByteArray(); 59 for(int i = 0; i < resBytes.length; i++) { 60 assertTrue(resBytes[i] == rBytes[i]); 61 } 62 assertEquals("incorrect sign", 1, result.signum()); 63 } 64 65 /** 66 * compareTo(BigInteger a). 67 * Compare two positive numbers. 68 * The first is greater. 69 */ 70 public void testCompareToPosPos1() { 71 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 72 byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30}; 73 int aSign = 1; 74 int bSign = 1; 75 BigInteger aNumber = new BigInteger(aSign, aBytes); 76 BigInteger bNumber = new BigInteger(bSign, bBytes); 77 assertEquals(1, aNumber.compareTo(bNumber)); 78 } 79 80 /** 81 * compareTo(BigInteger a). 82 * Compare two positive numbers. 83 * The first is less. 84 */ 85 public void testCompareToPosPos2() { 86 byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30}; 87 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 88 int aSign = 1; 89 int bSign = 1; 90 BigInteger aNumber = new BigInteger(aSign, aBytes); 91 BigInteger bNumber = new BigInteger(bSign, bBytes); 92 assertEquals(-1, aNumber.compareTo(bNumber)); 93 } 94 95 /** 96 * compareTo(BigInteger a). 97 * Compare two equal positive numbers. 98 */ 99 public void testCompareToEqualPos() { 100 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 101 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 102 int aSign = 1; 103 int bSign = 1; 104 BigInteger aNumber = new BigInteger(aSign, aBytes); 105 BigInteger bNumber = new BigInteger(bSign, bBytes); 106 assertEquals(0, aNumber.compareTo(bNumber)); 107 } 108 109 /** 110 * compareTo(BigInteger a). 111 * Compare two negative numbers. 112 * The first is greater in absolute value. 113 */ 114 public void testCompareToNegNeg1() { 115 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 116 byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30}; 117 int aSign = -1; 118 int bSign = -1; 119 BigInteger aNumber = new BigInteger(aSign, aBytes); 120 BigInteger bNumber = new BigInteger(bSign, bBytes); 121 assertEquals(-1, aNumber.compareTo(bNumber)); 122 } 123 124 /** 125 * compareTo(BigInteger a). 126 * Compare two negative numbers. 127 * The first is less in absolute value. 128 */ 129 public void testCompareNegNeg2() { 130 byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30}; 131 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 132 int aSign = -1; 133 int bSign = -1; 134 BigInteger aNumber = new BigInteger(aSign, aBytes); 135 BigInteger bNumber = new BigInteger(bSign, bBytes); 136 assertEquals(1, aNumber.compareTo(bNumber)); 137 } 138 139 /** 140 * compareTo(BigInteger a). 141 * Compare two equal negative numbers. 142 */ 143 public void testCompareToEqualNeg() { 144 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 145 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 146 int aSign = -1; 147 int bSign = -1; 148 BigInteger aNumber = new BigInteger(aSign, aBytes); 149 BigInteger bNumber = new BigInteger(bSign, bBytes); 150 assertEquals(0, aNumber.compareTo(bNumber)); 151 } 152 153 /** 154 * compareTo(BigInteger a). 155 * Compare two numbers of different signs. 156 * The first is positive. 157 */ 158 public void testCompareToDiffSigns1() { 159 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 160 byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30}; 161 int aSign = 1; 162 int bSign = -1; 163 BigInteger aNumber = new BigInteger(aSign, aBytes); 164 BigInteger bNumber = new BigInteger(bSign, bBytes); 165 assertEquals(1, aNumber.compareTo(bNumber)); 166 } 167 168 /** 169 * compareTo(BigInteger a). 170 * Compare two numbers of different signs. 171 * The first is negative. 172 */ 173 public void testCompareToDiffSigns2() { 174 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 175 byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30}; 176 int aSign = -1; 177 int bSign = 1; 178 BigInteger aNumber = new BigInteger(aSign, aBytes); 179 BigInteger bNumber = new BigInteger(bSign, bBytes); 180 assertEquals(-1, aNumber.compareTo(bNumber)); 181 } 182 183 /** 184 * compareTo(BigInteger a). 185 * Compare a positive number to ZERO. 186 */ 187 public void testCompareToPosZero() { 188 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 189 int aSign = 1; 190 BigInteger aNumber = new BigInteger(aSign, aBytes); 191 BigInteger bNumber = BigInteger.ZERO; 192 assertEquals(1, aNumber.compareTo(bNumber)); 193 } 194 195 /** 196 * compareTo(BigInteger a). 197 * Compare ZERO to a positive number. 198 */ 199 public void testCompareToZeroPos() { 200 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 201 int bSign = 1; 202 BigInteger aNumber = BigInteger.ZERO; 203 BigInteger bNumber = new BigInteger(bSign, bBytes); 204 assertEquals(-1, aNumber.compareTo(bNumber)); 205 } 206 207 /** 208 * compareTo(BigInteger a). 209 * Compare a negative number to ZERO. 210 */ 211 public void testCompareToNegZero() { 212 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 213 int aSign = -1; 214 BigInteger aNumber = new BigInteger(aSign, aBytes); 215 BigInteger bNumber = BigInteger.ZERO; 216 assertEquals(-1, aNumber.compareTo(bNumber)); 217 } 218 219 /** 220 * compareTo(BigInteger a). 221 * Compare ZERO to a negative number. 222 */ 223 public void testCompareToZeroNeg() { 224 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 225 int bSign = -1; 226 BigInteger aNumber = BigInteger.ZERO; 227 BigInteger bNumber = new BigInteger(bSign, bBytes); 228 assertEquals(1, aNumber.compareTo(bNumber)); 229 } 230 231 /** 232 * compareTo(BigInteger a). 233 * Compare ZERO to ZERO. 234 */ 235 public void testCompareToZeroZero() { 236 BigInteger aNumber = BigInteger.ZERO; 237 BigInteger bNumber = BigInteger.ZERO; 238 assertEquals(0, aNumber.compareTo(bNumber)); 239 } 240 241 /** 242 * equals(Object obj). 243 * obj is not a BigInteger 244 */ 245 public void testEqualsObject() { 246 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 247 int aSign = 1; 248 BigInteger aNumber = new BigInteger(aSign, aBytes); 249 Object obj = new Object(); 250 assertFalse(aNumber.equals(obj)); 251 } 252 253 /** 254 * equals(null). 255 */ 256 public void testEqualsNull() { 257 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 258 int aSign = 1; 259 BigInteger aNumber = new BigInteger(aSign, aBytes); 260 assertFalse(aNumber.equals(null)); 261 } 262 263 /** 264 * equals(Object obj). 265 * obj is a BigInteger. 266 * numbers are equal. 267 */ 268 public void testEqualsBigIntegerTrue() { 269 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 270 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 271 int aSign = 1; 272 int bSign = 1; 273 BigInteger aNumber = new BigInteger(aSign, aBytes); 274 Object bNumber = new BigInteger(bSign, bBytes); 275 assertTrue(aNumber.equals(bNumber)); 276 } 277 278 /** 279 * equals(Object obj). 280 * obj is a BigInteger. 281 * numbers are not equal. 282 */ 283 public void testEqualsBigIntegerFalse() { 284 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 285 byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 286 int aSign = 1; 287 int bSign = 1; 288 BigInteger aNumber = new BigInteger(aSign, aBytes); 289 Object bNumber = new BigInteger(bSign, bBytes); 290 assertFalse(aNumber.equals(bNumber)); 291 } 292 293 /** 294 * max(BigInteger val). 295 * the first is greater. 296 */ 297 public void testMaxGreater() { 298 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 299 byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 300 int aSign = 1; 301 int bSign = 1; 302 byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 303 BigInteger aNumber = new BigInteger(aSign, aBytes); 304 BigInteger bNumber = new BigInteger(bSign, bBytes); 305 BigInteger result = aNumber.max(bNumber); 306 byte resBytes[] = new byte[rBytes.length]; 307 resBytes = result.toByteArray(); 308 for(int i = 0; i < resBytes.length; i++) { 309 assertTrue(resBytes[i] == rBytes[i]); 310 } 311 assertTrue("incorrect sign", result.signum() == 1); 312 } 313 314 /** 315 * max(BigInteger val). 316 * the first is less. 317 */ 318 public void testMaxLess() { 319 byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 320 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 321 int aSign = 1; 322 int bSign = 1; 323 byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 324 BigInteger aNumber = new BigInteger(aSign, aBytes); 325 BigInteger bNumber = new BigInteger(bSign, bBytes); 326 BigInteger result = aNumber.max(bNumber); 327 byte resBytes[] = new byte[rBytes.length]; 328 resBytes = result.toByteArray(); 329 for(int i = 0; i < resBytes.length; i++) { 330 assertTrue(resBytes[i] == rBytes[i]); 331 } 332 assertTrue("incorrect sign", result.signum() == 1); 333 } 334 335 /** 336 * max(BigInteger val). 337 * numbers are equal. 338 */ 339 public void testMaxEqual() { 340 byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 341 byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 342 int aSign = 1; 343 int bSign = 1; 344 byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 345 BigInteger aNumber = new BigInteger(aSign, aBytes); 346 BigInteger bNumber = new BigInteger(bSign, bBytes); 347 BigInteger result = aNumber.max(bNumber); 348 byte resBytes[] = new byte[rBytes.length]; 349 resBytes = result.toByteArray(); 350 for(int i = 0; i < resBytes.length; i++) { 351 assertTrue(resBytes[i] == rBytes[i]); 352 } 353 assertEquals("incorrect sign", 1, result.signum()); 354 } 355 356 /** 357 * max(BigInteger val). 358 * max of negative and ZERO. 359 */ 360 public void testMaxNegZero() { 361 byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 362 int aSign = -1; 363 byte rBytes[] = {0}; 364 BigInteger aNumber = new BigInteger(aSign, aBytes); 365 BigInteger bNumber = BigInteger.ZERO; 366 BigInteger result = aNumber.max(bNumber); 367 byte resBytes[] = new byte[rBytes.length]; 368 resBytes = result.toByteArray(); 369 for(int i = 0; i < resBytes.length; i++) { 370 assertTrue(resBytes[i] == rBytes[i]); 371 } 372 assertTrue("incorrect sign", result.signum() == 0); 373 } 374 375 /** 376 * min(BigInteger val). 377 * the first is greater. 378 */ 379 public void testMinGreater() { 380 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 381 byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 382 int aSign = 1; 383 int bSign = 1; 384 byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 385 BigInteger aNumber = new BigInteger(aSign, aBytes); 386 BigInteger bNumber = new BigInteger(bSign, bBytes); 387 BigInteger result = aNumber.min(bNumber); 388 byte resBytes[] = new byte[rBytes.length]; 389 resBytes = result.toByteArray(); 390 for(int i = 0; i < resBytes.length; i++) { 391 assertTrue(resBytes[i] == rBytes[i]); 392 } 393 assertEquals("incorrect sign", 1, result.signum()); 394 } 395 396 /** 397 * min(BigInteger val). 398 * the first is less. 399 */ 400 public void testMinLess() { 401 byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 402 byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 403 int aSign = 1; 404 int bSign = 1; 405 byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 406 BigInteger aNumber = new BigInteger(aSign, aBytes); 407 BigInteger bNumber = new BigInteger(bSign, bBytes); 408 BigInteger result = aNumber.min(bNumber); 409 byte resBytes[] = new byte[rBytes.length]; 410 resBytes = result.toByteArray(); 411 for(int i = 0; i < resBytes.length; i++) { 412 assertTrue(resBytes[i] == rBytes[i]); 413 } 414 assertEquals("incorrect sign", 1, result.signum()); 415 } 416 417 /** 418 * min(BigInteger val). 419 * numbers are equal. 420 */ 421 public void testMinEqual() { 422 byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 423 byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 424 int aSign = 1; 425 int bSign = 1; 426 byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 427 BigInteger aNumber = new BigInteger(aSign, aBytes); 428 BigInteger bNumber = new BigInteger(bSign, bBytes); 429 BigInteger result = aNumber.min(bNumber); 430 byte resBytes[] = new byte[rBytes.length]; 431 resBytes = result.toByteArray(); 432 for(int i = 0; i < resBytes.length; i++) { 433 assertTrue(resBytes[i] == rBytes[i]); 434 } 435 assertTrue("incorrect sign", result.signum() == 1); 436 } 437 438 /** 439 * max(BigInteger val). 440 * min of positive and ZERO. 441 */ 442 public void testMinPosZero() { 443 byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91}; 444 int aSign = 1; 445 byte rBytes[] = {0}; 446 BigInteger aNumber = new BigInteger(aSign, aBytes); 447 BigInteger bNumber = BigInteger.ZERO; 448 BigInteger result = aNumber.min(bNumber); 449 byte resBytes[] = new byte[rBytes.length]; 450 resBytes = result.toByteArray(); 451 for(int i = 0; i < resBytes.length; i++) { 452 assertTrue(resBytes[i] == rBytes[i]); 453 } 454 assertTrue("incorrect sign", result.signum() == 0); 455 } 456 457 /** 458 * negate() a positive number. 459 */ 460 public void testNegatePositive() { 461 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 462 int aSign = 1; 463 byte rBytes[] = {-13, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -27, -4, -91}; 464 BigInteger aNumber = new BigInteger(aSign, aBytes); 465 BigInteger result = aNumber.negate(); 466 byte resBytes[] = new byte[rBytes.length]; 467 resBytes = result.toByteArray(); 468 for(int i = 0; i < resBytes.length; i++) { 469 assertTrue(resBytes[i] == rBytes[i]); 470 } 471 assertTrue("incorrect sign", result.signum() == -1); 472 } 473 474 /** 475 * negate() a negative number. 476 */ 477 public void testNegateNegative() { 478 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 479 int aSign = -1; 480 byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 481 BigInteger aNumber = new BigInteger(aSign, aBytes); 482 BigInteger result = aNumber.negate(); 483 byte resBytes[] = new byte[rBytes.length]; 484 resBytes = result.toByteArray(); 485 for(int i = 0; i < resBytes.length; i++) { 486 assertTrue(resBytes[i] == rBytes[i]); 487 } 488 assertTrue("incorrect sign", result.signum() == 1); 489 } 490 491 /** 492 * negate() ZERO. 493 */ 494 public void testNegateZero() { 495 byte rBytes[] = {0}; 496 BigInteger aNumber = BigInteger.ZERO; 497 BigInteger result = aNumber.negate(); 498 byte resBytes[] = new byte[rBytes.length]; 499 resBytes = result.toByteArray(); 500 for(int i = 0; i < resBytes.length; i++) { 501 assertTrue(resBytes[i] == rBytes[i]); 502 } 503 assertEquals("incorrect sign", 0, result.signum()); 504 } 505 506 /** 507 * signum() of a positive number. 508 */ 509 public void testSignumPositive() { 510 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 511 int aSign = 1; 512 BigInteger aNumber = new BigInteger(aSign, aBytes); 513 assertEquals("incorrect sign", 1, aNumber.signum()); 514 } 515 516 /** 517 * signum() of a negative number. 518 */ 519 public void testSignumNegative() { 520 byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; 521 int aSign = -1; 522 BigInteger aNumber = new BigInteger(aSign, aBytes); 523 assertEquals("incorrect sign", -1, aNumber.signum()); 524 } 525 526 /** 527 * signum() of ZERO. 528 */ 529 public void testSignumZero() { 530 BigInteger aNumber = BigInteger.ZERO; 531 assertEquals("incorrect sign", 0, aNumber.signum()); 532 } 533 } 534
