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