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: and
29 */
30public class BigIntegerAndTest extends TestCase {
31    /**
32     * And for zero and a positive number
33     */
34    public void testZeroPos() {
35        byte aBytes[] = {0};
36        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
37        int aSign = 0;
38        int bSign = 1;
39        byte rBytes[] = {0};
40        BigInteger aNumber = new BigInteger(aSign, aBytes);
41        BigInteger bNumber = new BigInteger(bSign, bBytes);
42        BigInteger result = aNumber.and(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", 0, result.signum());
49    }
50
51    /**
52     * And for zero and a negative number
53     */
54    public void testZeroNeg() {
55        byte aBytes[] = {0};
56        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
57        int aSign = 0;
58        int bSign = -1;
59        byte rBytes[] = {0};
60        BigInteger aNumber = new BigInteger(aSign, aBytes);
61        BigInteger bNumber = new BigInteger(bSign, bBytes);
62        BigInteger result = aNumber.and(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", 0, result.signum());
69    }
70
71    /**
72     * And for a positive number and zero
73     */
74    public void testPosZero() {
75        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
76        byte bBytes[] = {0};
77        int aSign = 1;
78        int bSign = 0;
79        byte rBytes[] = {0};
80        BigInteger aNumber = new BigInteger(aSign, aBytes);
81        BigInteger bNumber = new BigInteger(bSign, bBytes);
82        BigInteger result = aNumber.and(bNumber);
83        byte resBytes[] = new byte[rBytes.length];
84        resBytes = result.toByteArray();
85        for(int i = 0; i < resBytes.length; i++) {
86            assertTrue(resBytes[i] == rBytes[i]);
87        }
88        assertEquals("incorrect sign", 0, result.signum());
89    }
90
91    /**
92     * And for a negative number and zero
93     */
94    public void testNegPos() {
95        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
96        byte bBytes[] = {0};
97        int aSign = -1;
98        int bSign = 0;
99        byte rBytes[] = {0};
100        BigInteger aNumber = new BigInteger(aSign, aBytes);
101        BigInteger bNumber = new BigInteger(bSign, bBytes);
102        BigInteger result = aNumber.and(bNumber);
103        byte resBytes[] = new byte[rBytes.length];
104        resBytes = result.toByteArray();
105        for(int i = 0; i < resBytes.length; i++) {
106            assertTrue(resBytes[i] == rBytes[i]);
107        }
108        assertEquals("incorrect sign", 0, result.signum());
109    }
110
111    /**
112     * And for zero and zero
113     */
114    public void testZeroZero() {
115        byte aBytes[] = {0};
116        byte bBytes[] = {0};
117        int aSign = 0;
118        int bSign = 0;
119        byte rBytes[] = {0};
120        BigInteger aNumber = new BigInteger(aSign, aBytes);
121        BigInteger bNumber = new BigInteger(bSign, bBytes);
122        BigInteger result = aNumber.and(bNumber);
123        byte resBytes[] = new byte[rBytes.length];
124        resBytes = result.toByteArray();
125        for(int i = 0; i < resBytes.length; i++) {
126            assertTrue(resBytes[i] == rBytes[i]);
127        }
128        assertEquals("incorrect sign", 0, result.signum());
129    }
130
131    /**
132     * And for zero and one
133     */
134    public void testZeroOne() {
135        BigInteger aNumber = BigInteger.ZERO;
136        BigInteger bNumber = BigInteger.ONE;
137        BigInteger result = aNumber.and(bNumber);
138        assertTrue(result.equals(BigInteger.ZERO));
139        assertEquals("incorrect sign", 0, result.signum());
140    }
141
142    /**
143     * And for one and one
144     */
145    public void testOneOne() {
146        BigInteger aNumber = BigInteger.ONE;
147        BigInteger bNumber = BigInteger.ONE;
148        BigInteger result = aNumber.and(bNumber);
149        assertTrue(result.equals(BigInteger.ONE));
150        assertEquals("incorrect sign", 1, result.signum());
151    }
152
153    /**
154     * And for two positive numbers of the same length
155     */
156    public void testPosPosSameLength() {
157        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
158        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
159        int aSign = 1;
160        int bSign = 1;
161        byte rBytes[] = {0, -128, 56, 100, 4, 4, 17, 37, 16, 1, 64, 1, 10, 3};
162        BigInteger aNumber = new BigInteger(aSign, aBytes);
163        BigInteger bNumber = new BigInteger(bSign, bBytes);
164        BigInteger result = aNumber.and(bNumber);
165        byte resBytes[] = new byte[rBytes.length];
166        resBytes = result.toByteArray();
167        for(int i = 0; i < resBytes.length; i++) {
168            assertTrue(resBytes[i] == rBytes[i]);
169        }
170        assertEquals("incorrect sign", 1, result.signum());
171    }
172
173    /**
174     * And for two positive numbers; the first is longer
175     */
176    public void testPosPosFirstLonger() {
177        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
178        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
179        int aSign = 1;
180        int bSign = 1;
181        byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
182        BigInteger aNumber = new BigInteger(aSign, aBytes);
183        BigInteger bNumber = new BigInteger(bSign, bBytes);
184        BigInteger result = aNumber.and(bNumber);
185        byte resBytes[] = new byte[rBytes.length];
186        resBytes = result.toByteArray();
187        for(int i = 0; i < resBytes.length; i++) {
188            assertTrue(resBytes[i] == rBytes[i]);
189        }
190        assertEquals("incorrect sign", 1, result.signum());
191    }
192
193    /**
194     * And for two positive numbers; the first is shorter
195     */
196    public void testPosPosFirstShorter() {
197        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
198        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
199        int aSign = 1;
200        int bSign = 1;
201        byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
202        BigInteger aNumber = new BigInteger(aSign, aBytes);
203        BigInteger bNumber = new BigInteger(bSign, bBytes);
204        BigInteger result = aNumber.and(bNumber);
205        byte resBytes[] = new byte[rBytes.length];
206        resBytes = result.toByteArray();
207        for(int i = 0; i < resBytes.length; i++) {
208            assertTrue(resBytes[i] == rBytes[i]);
209        }
210        assertEquals("incorrect sign", 1, result.signum());
211    }
212
213    /**
214     * And for two negative numbers of the same length
215     */
216    public void testNegNegSameLength() {
217        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
218        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
219        int aSign = -1;
220        int bSign = -1;
221        byte rBytes[] = {-1, 1, 2, 3, 3, 0, 65, -96, -48, -124, -60, 12, -40, -31, 97};
222        BigInteger aNumber = new BigInteger(aSign, aBytes);
223        BigInteger bNumber = new BigInteger(bSign, bBytes);
224        BigInteger result = aNumber.and(bNumber);
225        byte resBytes[] = new byte[rBytes.length];
226        resBytes = result.toByteArray();
227        for(int i = 0; i < resBytes.length; i++) {
228            assertTrue(resBytes[i] == rBytes[i]);
229        }
230        assertEquals("incorrect sign", -1, result.signum());
231    }
232
233    /**
234     * And for two negative numbers; the first is longer
235     */
236    public void testNegNegFirstLonger() {
237        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
238        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
239        int aSign = -1;
240        int bSign = -1;
241        byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
242        BigInteger aNumber = new BigInteger(aSign, aBytes);
243        BigInteger bNumber = new BigInteger(bSign, bBytes);
244        BigInteger result = aNumber.and(bNumber);
245        byte resBytes[] = new byte[rBytes.length];
246        resBytes = result.toByteArray();
247        for(int i = 0; i < resBytes.length; i++) {
248            assertTrue(resBytes[i] == rBytes[i]);
249        }
250        assertEquals("incorrect sign", -1, result.signum());
251    }
252
253    /**
254     * And for two negative numbers; the first is shorter
255     */
256    public void testNegNegFirstShorter() {
257        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
258        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
259        int aSign = -1;
260        int bSign = -1;
261        byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
262        BigInteger aNumber = new BigInteger(aSign, aBytes);
263        BigInteger bNumber = new BigInteger(bSign, bBytes);
264        BigInteger result = aNumber.and(bNumber);
265        byte resBytes[] = new byte[rBytes.length];
266        resBytes = result.toByteArray();
267        for(int i = 0; i < resBytes.length; i++) {
268            assertTrue(resBytes[i] == rBytes[i]);
269        }
270        assertEquals("incorrect sign", -1, result.signum());
271    }
272
273    /**
274     * And for two numbers of different signs and the same length
275     */
276    public void testPosNegSameLength() {
277        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
278        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
279        int aSign = 1;
280        int bSign = -1;
281        byte rBytes[] = {0, -6, -80, 72, 8, 75, 2, -79, 34, 16, -119};
282        BigInteger aNumber = new BigInteger(aSign, aBytes);
283        BigInteger bNumber = new BigInteger(bSign, bBytes);
284        BigInteger result = aNumber.and(bNumber);
285        byte resBytes[] = new byte[rBytes.length];
286        resBytes = result.toByteArray();
287        for(int i = 0; i < resBytes.length; i++) {
288            assertTrue(resBytes[i] == rBytes[i]);
289        }
290        assertEquals("incorrect sign", 1, result.signum());
291    }
292
293    /**
294     * And for two numbers of different signs and the same length
295     */
296    public void testNegPosSameLength() {
297        byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
298        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
299        int aSign = -1;
300        int bSign = 1;
301        byte rBytes[] = {0, -2, 125, -60, -104, 1, 10, 6, 2, 32, 56, 2, 4, 4, 21};
302        BigInteger aNumber = new BigInteger(aSign, aBytes);
303        BigInteger bNumber = new BigInteger(bSign, bBytes);
304        BigInteger result = aNumber.and(bNumber);
305        byte resBytes[] = new byte[rBytes.length];
306        resBytes = result.toByteArray();
307        for(int i = 0; i < resBytes.length; i++) {
308            assertTrue(resBytes[i] == rBytes[i]);
309        }
310        assertEquals("incorrect sign", 1, result.signum());
311    }
312
313    /**
314     * And for a negative and a positive numbers; the first is longer
315     */
316    public void testNegPosFirstLonger() {
317        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
318        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
319        int aSign = -1;
320        int bSign = 1;
321        byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
322        BigInteger aNumber = new BigInteger(aSign, aBytes);
323        BigInteger bNumber = new BigInteger(bSign, bBytes);
324        BigInteger result = aNumber.and(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("incorrect sign", 1, result.signum());
331    }
332
333    /**
334     * And for a negative and a positive numbers; the first is shorter
335     */
336    public void testNegPosFirstShorter() {
337        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
338        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
339        int aSign = -1;
340        int bSign = 1;
341        byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
342        BigInteger aNumber = new BigInteger(aSign, aBytes);
343        BigInteger bNumber = new BigInteger(bSign, bBytes);
344        BigInteger result = aNumber.and(bNumber);
345        byte resBytes[] = new byte[rBytes.length];
346        resBytes = result.toByteArray();
347        for(int i = 0; i < resBytes.length; i++) {
348            assertTrue(resBytes[i] == rBytes[i]);
349        }
350        assertEquals("incorrect sign", 1, result.signum());
351    }
352
353    /**
354     * And for a positive and a negative numbers; the first is longer
355     */
356    public void testPosNegFirstLonger() {
357        byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
358        byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
359        int aSign = 1;
360        int bSign = -1;
361        byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
362        BigInteger aNumber = new BigInteger(aSign, aBytes);
363        BigInteger bNumber = new BigInteger(bSign, bBytes);
364        BigInteger result = aNumber.and(bNumber);
365        byte resBytes[] = new byte[rBytes.length];
366        resBytes = result.toByteArray();
367        for(int i = 0; i < resBytes.length; i++) {
368            assertTrue(resBytes[i] == rBytes[i]);
369        }
370        assertEquals("incorrect sign", 1, result.signum());
371    }
372
373    /**
374     * And for a positive and a negative numbers; the first is shorter
375     */
376    public void testPosNegFirstShorter() {
377        byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
378        byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
379        int aSign = 1;
380        int bSign = -1;
381        byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
382        BigInteger aNumber = new BigInteger(aSign, aBytes);
383        BigInteger bNumber = new BigInteger(bSign, bBytes);
384        BigInteger result = aNumber.and(bNumber);
385        byte resBytes[] = new byte[rBytes.length];
386        resBytes = result.toByteArray();
387        for(int i = 0; i < resBytes.length; i++) {
388            assertTrue(resBytes[i] == rBytes[i]);
389        }
390        assertEquals("incorrect sign", 1, result.signum());
391    }
392
393    /**
394     * Test for a special case
395     */
396    public void testSpecialCase1() {
397        byte aBytes[] = {-1, -1, -1, -1};
398        byte bBytes[] = {5, -4, -3, -2};
399        int aSign = -1;
400        int bSign = -1;
401        byte rBytes[] = {-1, 0, 0, 0, 0};
402        BigInteger aNumber = new BigInteger(aSign, aBytes);
403        BigInteger bNumber = new BigInteger(bSign, bBytes);
404        BigInteger result = aNumber.and(bNumber);
405        byte resBytes[] = new byte[rBytes.length];
406        resBytes = result.toByteArray();
407        for(int i = 0; i < resBytes.length; i++) {
408            assertTrue(resBytes[i] == rBytes[i]);
409        }
410        assertEquals("incorrect sign", -1, result.signum());
411    }
412
413    /**
414     * Test for a special case
415     */
416    public void testSpecialCase2() {
417        byte aBytes[] = {-51};
418        byte bBytes[] = {-52, -51, -50, -49, -48};
419        int aSign = -1;
420        int bSign = 1;
421        byte rBytes[] = {0, -52, -51, -50, -49, 16};
422        BigInteger aNumber = new BigInteger(aSign, aBytes);
423        BigInteger bNumber = new BigInteger(bSign, bBytes);
424        BigInteger result = aNumber.and(bNumber);
425        byte resBytes[] = new byte[rBytes.length];
426        resBytes = result.toByteArray();
427        for(int i = 0; i < resBytes.length; i++) {
428            assertTrue(resBytes[i] == rBytes[i]);
429        }
430        assertEquals("incorrect sign", 1, result.signum());
431    }
432}
433