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
21package org.apache.harmony.tests.java.math;
22
23import junit.framework.TestCase;
24import java.math.BigInteger;
25
26/**
27 * Class:  java.math.BigInteger
28 * Method: add
29 */
30public 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