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