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: subtract
29 */
30public 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