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