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 * Methods: divide, remainder, mod, and divideAndRemainder
29 */
30public class BigIntegerDivideTest extends TestCase {
31    /**
32     * Divide by zero
33     */
34    public void testCase1() {
35        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
36        byte bBytes[] = {0};
37        int aSign = 1;
38        int bSign = 0;
39        BigInteger aNumber = new BigInteger(aSign, aBytes);
40        BigInteger bNumber = new BigInteger(bSign, bBytes);
41        try {
42            aNumber.divide(bNumber);
43            fail("ArithmeticException has not been caught");
44        } catch (ArithmeticException e) {
45        }
46    }
47
48    /**
49     * Divide by ZERO
50     */
51    public void testCase2() {
52        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
53        int aSign = 1;
54        BigInteger aNumber = new BigInteger(aSign, aBytes);
55        BigInteger bNumber = BigInteger.ZERO;
56        try {
57            aNumber.divide(bNumber);
58            fail("ArithmeticException has not been caught");
59        } catch (ArithmeticException e) {
60        }
61    }
62
63    /**
64     * Divide two equal positive numbers
65     */
66    public void testCase3() {
67        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
68        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
69        int aSign = 1;
70        int bSign = 1;
71        byte rBytes[] = {1};
72        BigInteger aNumber = new BigInteger(aSign, aBytes);
73        BigInteger bNumber = new BigInteger(bSign, bBytes);
74        BigInteger result = aNumber.divide(bNumber);
75        byte resBytes[] = new byte[rBytes.length];
76        resBytes = result.toByteArray();
77        for(int i = 0; i < resBytes.length; i++) {
78            assertTrue(resBytes[i] == rBytes[i]);
79        }
80        assertEquals("incorrect sign", 1, result.signum());
81    }
82
83    /**
84     * Divide two equal in absolute value numbers of different signs.
85     */
86    public void testCase4() {
87        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
88        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
89        int aSign = -1;
90        int bSign = 1;
91        byte rBytes[] = {-1};
92        BigInteger aNumber = new BigInteger(aSign, aBytes);
93        BigInteger bNumber = new BigInteger(bSign, bBytes);
94        BigInteger result = aNumber.divide(bNumber);
95        byte resBytes[] = new byte[rBytes.length];
96        resBytes = result.toByteArray();
97        for(int i = 0; i < resBytes.length; i++) {
98            assertTrue(resBytes[i] == rBytes[i]);
99        }
100        assertEquals("incorrect sign", -1, result.signum());
101    }
102
103    /**
104     * Divide two numbers of different length and different signs.
105     * The second is longer.
106     */
107    public void testCase5() {
108        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
109        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 1, 2, 3, 4, 5};
110        int aSign = -1;
111        int bSign = 1;
112        byte rBytes[] = {0};
113        BigInteger aNumber = new BigInteger(aSign, aBytes);
114        BigInteger bNumber = new BigInteger(bSign, bBytes);
115        BigInteger result = aNumber.divide(bNumber);
116        byte resBytes[] = new byte[rBytes.length];
117        resBytes = result.toByteArray();
118        for(int i = 0; i < resBytes.length; i++) {
119            assertTrue(resBytes[i] == rBytes[i]);
120        }
121        assertEquals("incorrect sign", 0, result.signum());
122    }
123
124    /**
125     * Divide two positive numbers of the same length.
126     * The second is greater.
127     */
128    public void testCase6() {
129        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127};
130        byte bBytes[] = {15, 100, 56, 7, 98, -1, 39, -128, 127};
131        int aSign = 1;
132        int bSign = 1;
133        byte rBytes[] = {0};
134        BigInteger aNumber = new BigInteger(aSign, aBytes);
135        BigInteger bNumber = new BigInteger(bSign, bBytes);
136        BigInteger result = aNumber.divide(bNumber);
137        byte resBytes[] = new byte[rBytes.length];
138        resBytes = result.toByteArray();
139        for(int i = 0; i < resBytes.length; i++) {
140            assertTrue(resBytes[i] == rBytes[i]);
141        }
142        assertEquals("incorrect sign", 0, result.signum());
143    }
144
145    /**
146     * Divide two positive numbers.
147     */
148    public void testCase7() {
149        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
150        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
151        int aSign = 1;
152        int bSign = 1;
153        byte rBytes[] = {23, 115, 11, 78, 35, -11};
154        BigInteger aNumber = new BigInteger(aSign, aBytes);
155        BigInteger bNumber = new BigInteger(bSign, bBytes);
156        BigInteger result = aNumber.divide(bNumber);
157        byte resBytes[] = new byte[rBytes.length];
158        resBytes = result.toByteArray();
159        for(int i = 0; i < resBytes.length; i++) {
160            assertTrue(resBytes[i] == rBytes[i]);
161        }
162        assertEquals("incorrect sign", 1, result.signum());
163    }
164
165    /**
166     * Divide a positive number by a negative one.
167     */
168    public void testCase8() {
169        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
170        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
171        int aSign = 1;
172        int bSign = -1;
173        byte rBytes[] = {-24, -116, -12, -79, -36, 11};
174        BigInteger aNumber = new BigInteger(aSign, aBytes);
175        BigInteger bNumber = new BigInteger(bSign, bBytes);
176        BigInteger result = aNumber.divide(bNumber);
177        byte resBytes[] = new byte[rBytes.length];
178        resBytes = result.toByteArray();
179        for(int i = 0; i < resBytes.length; i++) {
180            assertTrue(resBytes[i] == rBytes[i]);
181        }
182        assertEquals("incorrect sign", -1, result.signum());
183    }
184
185    /**
186     * Divide a negative number by a positive one.
187     */
188    public void testCase9() {
189        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
190        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
191        int aSign = -1;
192        int bSign = 1;
193        byte rBytes[] = {-24, -116, -12, -79, -36, 11};
194        BigInteger aNumber = new BigInteger(aSign, aBytes);
195        BigInteger bNumber = new BigInteger(bSign, bBytes);
196        BigInteger result = aNumber.divide(bNumber);
197        byte resBytes[] = new byte[rBytes.length];
198        resBytes = result.toByteArray();
199        for(int i = 0; i < resBytes.length; i++) {
200            assertTrue(resBytes[i] == rBytes[i]);
201        }
202        assertEquals("incorrect sign", -1, result.signum());
203    }
204
205    /**
206     * Divide two negative numbers.
207     */
208    public void testCase10() {
209        byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
210        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
211        int aSign = -1;
212        int bSign = -1;
213        byte rBytes[] = {23, 115, 11, 78, 35, -11};
214        BigInteger aNumber = new BigInteger(aSign, aBytes);
215        BigInteger bNumber = new BigInteger(bSign, bBytes);
216        BigInteger result = aNumber.divide(bNumber);
217        byte resBytes[] = new byte[rBytes.length];
218        resBytes = result.toByteArray();
219        for(int i = 0; i < resBytes.length; i++) {
220            assertTrue(resBytes[i] == rBytes[i]);
221        }
222        assertEquals("incorrect sign", 1, result.signum());
223    }
224
225    /**
226     * Divide zero by a negative number.
227     */
228    public void testCase11() {
229        byte aBytes[] = {0};
230        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
231        int aSign = 0;
232        int bSign = -1;
233        byte rBytes[] = {0};
234        BigInteger aNumber = new BigInteger(aSign, aBytes);
235        BigInteger bNumber = new BigInteger(bSign, bBytes);
236        BigInteger result = aNumber.divide(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("incorrect sign", 0, result.signum());
243    }
244
245    /**
246     * Divide ZERO by a negative number.
247     */
248    public void testCase12() {
249        byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
250        int bSign = -1;
251        byte rBytes[] = {0};
252        BigInteger aNumber = BigInteger.ZERO;
253        BigInteger bNumber = new BigInteger(bSign, bBytes);
254        BigInteger result = aNumber.divide(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", 0, result.signum());
261    }
262
263    /**
264     * Divide a positive number by ONE.
265     */
266    public void testCase13() {
267        byte aBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
268        int aSign = 1;
269        byte rBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
270        BigInteger aNumber = new BigInteger(aSign, aBytes);
271        BigInteger bNumber = BigInteger.ONE;
272        BigInteger result = aNumber.divide(bNumber);
273        byte resBytes[] = new byte[rBytes.length];
274        resBytes = result.toByteArray();
275        for(int i = 0; i < resBytes.length; i++) {
276            assertTrue(resBytes[i] == rBytes[i]);
277        }
278        assertEquals("incorrect sign", 1, result.signum());
279    }
280
281    /**
282     * Divide ONE by ONE.
283     */
284    public void testCase14() {
285        byte rBytes[] = {1};
286        BigInteger aNumber = BigInteger.ONE;
287        BigInteger bNumber = BigInteger.ONE;
288        BigInteger result = aNumber.divide(bNumber);
289        byte resBytes[] = new byte[rBytes.length];
290        resBytes = result.toByteArray();
291        for(int i = 0; i < resBytes.length; i++) {
292            assertTrue(resBytes[i] == rBytes[i]);
293        }
294        assertEquals("incorrect sign", 1, result.signum());
295    }
296
297    /**
298     * Verifies the case when borrow != 0 in the private divide method.
299     */
300    public void testDivisionKnuth1() {
301        byte aBytes[] = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
302        byte bBytes[] = {-3, -3, -3, -3};
303        int aSign = 1;
304        int bSign = 1;
305        byte rBytes[] = {0, -5, -12, -33, -96, -36, -105, -56, 92, 15, 48, -109};
306        BigInteger aNumber = new BigInteger(aSign, aBytes);
307        BigInteger bNumber = new BigInteger(bSign, bBytes);
308        BigInteger result = aNumber.divide(bNumber);
309        byte resBytes[] = new byte[rBytes.length];
310        resBytes = result.toByteArray();
311        for(int i = 0; i < resBytes.length; i++) {
312            assertTrue(resBytes[i] == rBytes[i]);
313        }
314        assertEquals("incorrect sign", 1, result.signum());
315    }
316
317    /**
318     * Verifies the case when the divisor is already normalized.
319     */
320    public void testDivisionKnuthIsNormalized() {
321        byte aBytes[] = {-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
322        byte bBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
323        int aSign = -1;
324        int bSign = -1;
325        byte rBytes[] = {0, -9, -8, -7, -6, -5, -4, -3};
326        BigInteger aNumber = new BigInteger(aSign, aBytes);
327        BigInteger bNumber = new BigInteger(bSign, bBytes);
328        BigInteger result = aNumber.divide(bNumber);
329        byte resBytes[] = new byte[rBytes.length];
330        resBytes = result.toByteArray();
331        for(int i = 0; i < resBytes.length; i++) {
332            assertTrue(resBytes[i] == rBytes[i]);
333        }
334        assertEquals("incorrect sign", 1, result.signum());
335    }
336
337    /**
338     * Verifies the case when the first digits of the dividend
339     * and divisor equal.
340     */
341    public void testDivisionKnuthFirstDigitsEqual() {
342        byte aBytes[] = {2, -3, -4, -5, -1, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
343        byte bBytes[] = {2, -3, -4, -5, -1, -1, -1, -1};
344        int aSign = -1;
345        int bSign = -1;
346        byte rBytes[] = {0, -1, -1, -1, -1, -2, -88, -60, 41};
347        BigInteger aNumber = new BigInteger(aSign, aBytes);
348        BigInteger bNumber = new BigInteger(bSign, bBytes);
349        BigInteger result = aNumber.divide(bNumber);
350        byte resBytes[] = new byte[rBytes.length];
351        resBytes = result.toByteArray();
352        for(int i = 0; i < resBytes.length; i++) {
353            assertTrue(resBytes[i] == rBytes[i]);
354        }
355        assertEquals("incorrect sign", 1, result.signum());
356    }
357
358    /**
359     * Divide the number of one digit by the number of one digit
360     */
361    public void testDivisionKnuthOneDigitByOneDigit() {
362        byte aBytes[] = {113, -83, 123, -5};
363        byte bBytes[] = {2, -3, -4, -5};
364        int aSign = 1;
365        int bSign = -1;
366        byte rBytes[] = {-37};
367        BigInteger aNumber = new BigInteger(aSign, aBytes);
368        BigInteger bNumber = new BigInteger(bSign, bBytes);
369        BigInteger result = aNumber.divide(bNumber);
370        byte resBytes[] = new byte[rBytes.length];
371        resBytes = result.toByteArray();
372        for(int i = 0; i < resBytes.length; i++) {
373            assertTrue(resBytes[i] == rBytes[i]);
374        }
375        assertEquals("incorrect sign", -1, result.signum());
376    }
377
378    /**
379     * Divide the number of multi digits by the number of one digit
380     */
381    public void testDivisionKnuthMultiDigitsByOneDigit() {
382        byte aBytes[] = {113, -83, 123, -5, 18, -34, 67, 39, -29};
383        byte bBytes[] = {2, -3, -4, -5};
384        int aSign = 1;
385        int bSign = -1;
386        byte rBytes[] = {-38, 2, 7, 30, 109, -43};
387        BigInteger aNumber = new BigInteger(aSign, aBytes);
388        BigInteger bNumber = new BigInteger(bSign, bBytes);
389        BigInteger result = aNumber.divide(bNumber);
390        byte resBytes[] = new byte[rBytes.length];
391        resBytes = result.toByteArray();
392        for(int i = 0; i < resBytes.length; i++) {
393            assertTrue(resBytes[i] == rBytes[i]);
394        }
395        assertEquals("incorrect sign", -1, result.signum());
396    }
397
398    /**
399     * Remainder of division by zero
400     */
401    public void testCase15() {
402        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
403        byte bBytes[] = {0};
404        int aSign = 1;
405        int bSign = 0;
406        BigInteger aNumber = new BigInteger(aSign, aBytes);
407        BigInteger bNumber = new BigInteger(bSign, bBytes);
408        try {
409            aNumber.remainder(bNumber);
410            fail("ArithmeticException has not been caught");
411        } catch (ArithmeticException e) {
412        }
413    }
414
415    /**
416     * Remainder of division of equal numbers
417     */
418    public void testCase16() {
419        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
420        byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
421        int aSign = 1;
422        int bSign = 1;
423        byte rBytes[] = {0};
424        BigInteger aNumber = new BigInteger(aSign, aBytes);
425        BigInteger bNumber = new BigInteger(bSign, bBytes);
426        BigInteger result = aNumber.remainder(bNumber);
427        byte resBytes[] = new byte[rBytes.length];
428        resBytes = result.toByteArray();
429        for(int i = 0; i < resBytes.length; i++) {
430            assertTrue(resBytes[i] == rBytes[i]);
431        }
432        assertEquals("incorrect sign", 0, result.signum());
433    }
434
435    /**
436     * Remainder of division of two positive numbers
437     */
438    public void testCase17() {
439        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
440        byte bBytes[] = {27, -15, 65, 39, 100};
441        int aSign = 1;
442        int bSign = 1;
443        byte rBytes[] = {12, -21, 73, 56, 27};
444        BigInteger aNumber = new BigInteger(aSign, aBytes);
445        BigInteger bNumber = new BigInteger(bSign, bBytes);
446        BigInteger result = aNumber.remainder(bNumber);
447        byte resBytes[] = new byte[rBytes.length];
448        resBytes = result.toByteArray();
449        for(int i = 0; i < resBytes.length; i++) {
450            assertTrue(resBytes[i] == rBytes[i]);
451        }
452        assertEquals("incorrect sign", 1, result.signum());
453    }
454
455    /**
456     * Remainder of division of two negative numbers
457     */
458    public void testCase18() {
459        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
460        byte bBytes[] = {27, -15, 65, 39, 100};
461        int aSign = -1;
462        int bSign = -1;
463        byte rBytes[] = {-13, 20, -74, -57, -27};
464        BigInteger aNumber = new BigInteger(aSign, aBytes);
465        BigInteger bNumber = new BigInteger(bSign, bBytes);
466        BigInteger result = aNumber.remainder(bNumber);
467        byte resBytes[] = new byte[rBytes.length];
468        resBytes = result.toByteArray();
469        for(int i = 0; i < resBytes.length; i++) {
470            assertTrue(resBytes[i] == rBytes[i]);
471        }
472        assertEquals("incorrect sign", -1, result.signum());
473    }
474
475    /**
476     * Remainder of division of two numbers of different signs.
477     * The first is positive.
478     */
479    public void testCase19() {
480        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
481        byte bBytes[] = {27, -15, 65, 39, 100};
482        int aSign = 1;
483        int bSign = -1;
484        byte rBytes[] = {12, -21, 73, 56, 27};
485        BigInteger aNumber = new BigInteger(aSign, aBytes);
486        BigInteger bNumber = new BigInteger(bSign, bBytes);
487        BigInteger result = aNumber.remainder(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    /**
497     * Remainder of division of two numbers of different signs.
498     * The first is negative.
499     */
500    public void testCase20() {
501        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
502        byte bBytes[] = {27, -15, 65, 39, 100};
503        int aSign = -1;
504        int bSign = 1;
505        byte rBytes[] = {-13, 20, -74, -57, -27};
506        BigInteger aNumber = new BigInteger(aSign, aBytes);
507        BigInteger bNumber = new BigInteger(bSign, bBytes);
508        BigInteger result = aNumber.remainder(bNumber);
509        byte resBytes[] = new byte[rBytes.length];
510        resBytes = result.toByteArray();
511        for(int i = 0; i < resBytes.length; i++) {
512            assertTrue(resBytes[i] == rBytes[i]);
513        }
514        assertEquals("incorrect sign", -1, result.signum());
515    }
516
517    /**
518     * Tests the step D6 from the Knuth algorithm
519     */
520    public void testRemainderKnuth1() {
521        byte aBytes[] = {-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1};
522        byte bBytes[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
523        int aSign = 1;
524        int bSign = 1;
525        byte rBytes[] = {1, 2, 3, 4, 5, 6, 7, 7, 18, -89};
526        BigInteger aNumber = new BigInteger(aSign, aBytes);
527        BigInteger bNumber = new BigInteger(bSign, bBytes);
528        BigInteger result = aNumber.remainder(bNumber);
529        byte resBytes[] = new byte[rBytes.length];
530        resBytes = result.toByteArray();
531        for(int i = 0; i < resBytes.length; i++) {
532            assertTrue(resBytes[i] == rBytes[i]);
533        }
534        assertEquals("incorrect sign", 1, result.signum());
535    }
536
537    /**
538     * Divide the number of one digit by the number of one digit
539     */
540    public void testRemainderKnuthOneDigitByOneDigit() {
541        byte aBytes[] = {113, -83, 123, -5};
542        byte bBytes[] = {2, -3, -4, -50};
543        int aSign = 1;
544        int bSign = -1;
545        byte rBytes[] = {2, -9, -14, 53};
546        BigInteger aNumber = new BigInteger(aSign, aBytes);
547        BigInteger bNumber = new BigInteger(bSign, bBytes);
548        BigInteger result = aNumber.remainder(bNumber);
549        byte resBytes[] = new byte[rBytes.length];
550        resBytes = result.toByteArray();
551        for(int i = 0; i < resBytes.length; i++) {
552            assertTrue(resBytes[i] == rBytes[i]);
553        }
554        assertEquals("incorrect sign", 1, result.signum());
555    }
556
557    /**
558     * Divide the number of multi digits by the number of one digit
559     */
560    public void testRemainderKnuthMultiDigitsByOneDigit() {
561        byte aBytes[] = {113, -83, 123, -5, 18, -34, 67, 39, -29};
562        byte bBytes[] = {2, -3, -4, -50};
563        int aSign = 1;
564        int bSign = -1;
565        byte rBytes[] = {2, -37, -60, 59};
566        BigInteger aNumber = new BigInteger(aSign, aBytes);
567        BigInteger bNumber = new BigInteger(bSign, bBytes);
568        BigInteger result = aNumber.remainder(bNumber);
569        byte resBytes[] = new byte[rBytes.length];
570        resBytes = result.toByteArray();
571        for(int i = 0; i < resBytes.length; i++) {
572            assertTrue(resBytes[i] == rBytes[i]);
573        }
574        assertEquals("incorrect sign", 1, result.signum());
575    }
576
577    /**
578     * divideAndRemainder of two numbers of different signs.
579     * The first is negative.
580     */
581    public void testCase21() {
582        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
583        byte bBytes[] = {27, -15, 65, 39, 100};
584        int aSign = -1;
585        int bSign = 1;
586        byte rBytes[][] = {
587                {-5, 94, -115, -74, -85, 84},
588                {-13, 20, -74, -57, -27}
589        };
590        BigInteger aNumber = new BigInteger(aSign, aBytes);
591        BigInteger bNumber = new BigInteger(bSign, bBytes);
592        BigInteger result[] = aNumber.divideAndRemainder(bNumber);
593        byte resBytes[] = new byte[rBytes.length];
594        resBytes = result[0].toByteArray();
595        for(int i = 0; i < resBytes.length; i++) {
596            if (resBytes[i] != rBytes[0][i]) {
597                fail("Incorrect quotation");
598            }
599        }
600        assertEquals(-1, result[0].signum());
601        resBytes = result[1].toByteArray();
602        for(int i = 0; i < resBytes.length; i++) {
603            if (resBytes[i] != rBytes[1][i]) {
604                fail("Incorrect remainder");
605            }
606            assertEquals(-1, result[1].signum());
607        }
608    }
609
610    /**
611     * mod when modulus is negative
612     */
613    public void testCase22() {
614        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
615        byte bBytes[] = {1, 30, 40, 56, -1, 45};
616        int aSign = 1;
617        int bSign = -1;
618        BigInteger aNumber = new BigInteger(aSign, aBytes);
619        BigInteger bNumber = new BigInteger(bSign, bBytes);
620        try {
621            aNumber.mod(bNumber);
622            fail("ArithmeticException has not been caught");
623        } catch (ArithmeticException e) {
624        }
625    }
626
627    /**
628     * mod when a divisor is positive
629     */
630    public void testCase23() {
631        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
632        byte bBytes[] = {27, -15, 65, 39, 100};
633        int aSign = 1;
634        int bSign = 1;
635        byte rBytes[] = {12, -21, 73, 56, 27};
636        BigInteger aNumber = new BigInteger(aSign, aBytes);
637        BigInteger bNumber = new BigInteger(bSign, bBytes);
638        BigInteger result = aNumber.mod(bNumber);
639        byte resBytes[] = new byte[rBytes.length];
640        resBytes = result.toByteArray();
641        for(int i = 0; i < resBytes.length; i++) {
642            assertTrue(resBytes[i] == rBytes[i]);
643        }
644        assertEquals("incorrect sign", 1, result.signum());
645    }
646
647    /**
648     * mod when a divisor is negative
649     */
650    public void testCase24() {
651        byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
652        byte bBytes[] = {27, -15, 65, 39, 100};
653        int aSign = -1;
654        int bSign = 1;
655        byte rBytes[] = {15, 5, -9, -17, 73};
656        BigInteger aNumber = new BigInteger(aSign, aBytes);
657        BigInteger bNumber = new BigInteger(bSign, bBytes);
658        BigInteger result = aNumber.mod(bNumber);
659        byte resBytes[] = new byte[rBytes.length];
660        resBytes = result.toByteArray();
661        for(int i = 0; i < resBytes.length; i++) {
662            assertTrue(resBytes[i] == rBytes[i]);
663        }
664        assertEquals("incorrect sign", 1, result.signum());
665    }
666}
667