001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: /**
018: * @author Elena Semukhina
019: * @version $Revision$
020: */package org.apache.harmony.tests.java.math;
021:
022: import junit.framework.TestCase;
023: import java.math.BigInteger;
024:
025: /**
026: * Class: java.math.BigInteger
027: * Method: subtract
028: */
029: public class BigIntegerSubtractTest extends TestCase {
030: /**
031: * Subtract two positive numbers of the same length.
032: * The first is greater.
033: */
034: public void testCase1() {
035: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
036: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3 };
037: int aSign = 1;
038: int bSign = 1;
039: byte rBytes[] = { 9, 18, 27, 36, 45, 54, 63, 9, 18, 27 };
040: BigInteger aNumber = new BigInteger(aSign, aBytes);
041: BigInteger bNumber = new BigInteger(bSign, bBytes);
042: BigInteger result = aNumber.subtract(bNumber);
043: byte resBytes[] = new byte[rBytes.length];
044: resBytes = result.toByteArray();
045: for (int i = 0; i < resBytes.length; i++) {
046: assertTrue(resBytes[i] == rBytes[i]);
047: }
048: assertEquals(1, result.signum());
049: }
050:
051: /**
052: * Subtract two positive numbers of the same length.
053: * The second is greater.
054: */
055: public void testCase2() {
056: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3 };
057: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
058: int aSign = 1;
059: int bSign = 1;
060: byte rBytes[] = { -10, -19, -28, -37, -46, -55, -64, -10, -19,
061: -27 };
062: BigInteger aNumber = new BigInteger(aSign, aBytes);
063: BigInteger bNumber = new BigInteger(bSign, bBytes);
064: BigInteger result = aNumber.subtract(bNumber);
065: byte resBytes[] = new byte[rBytes.length];
066: resBytes = result.toByteArray();
067: for (int i = 0; i < resBytes.length; i++) {
068: assertTrue(resBytes[i] == rBytes[i]);
069: }
070: assertEquals(-1, result.signum());
071: }
072:
073: /**
074: * Subtract two numbers of the same length and different signs.
075: * The first is positive.
076: * The first is greater in absolute value.
077: */
078: public void testCase3() {
079: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
080: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3 };
081: int aSign = 1;
082: int bSign = -1;
083: byte rBytes[] = { 11, 22, 33, 44, 55, 66, 77, 11, 22, 33 };
084: BigInteger aNumber = new BigInteger(aSign, aBytes);
085: BigInteger bNumber = new BigInteger(bSign, bBytes);
086: BigInteger result = aNumber.subtract(bNumber);
087: byte resBytes[] = new byte[rBytes.length];
088: resBytes = result.toByteArray();
089: for (int i = 0; i < resBytes.length; i++) {
090: assertTrue(resBytes[i] == rBytes[i]);
091: }
092: assertEquals(1, result.signum());
093: }
094:
095: /**
096: * Subtract two numbers of the same length and different signs.
097: * The first is positive.
098: * The second is greater in absolute value.
099: */
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,
127: -27 };
128: BigInteger aNumber = new BigInteger(aSign, aBytes);
129: BigInteger bNumber = new BigInteger(bSign, bBytes);
130: BigInteger result = aNumber.subtract(bNumber);
131: byte resBytes[] = new byte[rBytes.length];
132: resBytes = result.toByteArray();
133: for (int i = 0; i < resBytes.length; i++) {
134: assertTrue(resBytes[i] == rBytes[i]);
135: }
136: assertEquals(-1, result.signum());
137: }
138:
139: /**
140: * Subtract two negative numbers of the same length.
141: * The second is greater in absolute value.
142: */
143: public void testCase6() {
144: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3 };
145: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
146: int aSign = -1;
147: int bSign = -1;
148: byte rBytes[] = { 9, 18, 27, 36, 45, 54, 63, 9, 18, 27 };
149: BigInteger aNumber = new BigInteger(aSign, aBytes);
150: BigInteger bNumber = new BigInteger(bSign, bBytes);
151: BigInteger result = aNumber.subtract(bNumber);
152: byte resBytes[] = new byte[rBytes.length];
153: resBytes = result.toByteArray();
154: for (int i = 0; i < resBytes.length; i++) {
155: assertTrue(resBytes[i] == rBytes[i]);
156: }
157: assertEquals(1, result.signum());
158: }
159:
160: /**
161: * Subtract two numbers of the same length and different signs.
162: * The first is negative.
163: * The first is greater in absolute value.
164: */
165: public void testCase7() {
166: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
167: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3 };
168: int aSign = -1;
169: int bSign = 1;
170: byte rBytes[] = { -12, -23, -34, -45, -56, -67, -78, -12, -23,
171: -33 };
172: BigInteger aNumber = new BigInteger(aSign, aBytes);
173: BigInteger bNumber = new BigInteger(bSign, bBytes);
174: BigInteger result = aNumber.subtract(bNumber);
175: byte resBytes[] = new byte[rBytes.length];
176: resBytes = result.toByteArray();
177: for (int i = 0; i < resBytes.length; i++) {
178: assertTrue(resBytes[i] == rBytes[i]);
179: }
180: assertEquals(-1, result.signum());
181: }
182:
183: /**
184: * Subtract two numbers of the same length and different signs.
185: * The first is negative.
186: * The second is greater in absolute value.
187: */
188: public void testCase8() {
189: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3 };
190: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
191: int aSign = -1;
192: int bSign = 1;
193: byte rBytes[] = { -12, -23, -34, -45, -56, -67, -78, -12, -23,
194: -33 };
195: BigInteger aNumber = new BigInteger(aSign, aBytes);
196: BigInteger bNumber = new BigInteger(bSign, bBytes);
197: BigInteger result = aNumber.subtract(bNumber);
198: byte resBytes[] = new byte[rBytes.length];
199: resBytes = result.toByteArray();
200: for (int i = 0; i < resBytes.length; i++) {
201: assertTrue(resBytes[i] == rBytes[i]);
202: }
203: assertEquals(-1, result.signum());
204: }
205:
206: /**
207: * Subtract two positive numbers of different length.
208: * The first is longer.
209: */
210: public void testCase9() {
211: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
212: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
213: int aSign = 1;
214: int bSign = 1;
215: byte rBytes[] = { 1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67,
216: -6, -15, -23 };
217: BigInteger aNumber = new BigInteger(aSign, aBytes);
218: BigInteger bNumber = new BigInteger(bSign, bBytes);
219: BigInteger result = aNumber.subtract(bNumber);
220: byte resBytes[] = new byte[rBytes.length];
221: resBytes = result.toByteArray();
222: for (int i = 0; i < resBytes.length; i++) {
223: assertTrue(resBytes[i] == rBytes[i]);
224: }
225: assertEquals(1, result.signum());
226: }
227:
228: /**
229: * Subtract two positive numbers of different length.
230: * The second is longer.
231: */
232: public void testCase10() {
233: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
234: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
235: int aSign = 1;
236: int bSign = 1;
237: byte rBytes[] = { -2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5,
238: 14, 23 };
239: BigInteger aNumber = new BigInteger(aSign, aBytes);
240: BigInteger bNumber = new BigInteger(bSign, bBytes);
241: BigInteger result = aNumber.subtract(bNumber);
242: byte resBytes[] = new byte[rBytes.length];
243: resBytes = result.toByteArray();
244: for (int i = 0; i < resBytes.length; i++) {
245: assertTrue(resBytes[i] == rBytes[i]);
246: }
247: assertEquals(-1, result.signum());
248: }
249:
250: /**
251: * Subtract two numbers of different length and different signs.
252: * The first is positive.
253: * The first is greater in absolute value.
254: */
255: public void testCase11() {
256: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
257: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
258: int aSign = 1;
259: int bSign = -1;
260: byte rBytes[] = { 1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15,
261: 26, 37 };
262: BigInteger aNumber = new BigInteger(aSign, aBytes);
263: BigInteger bNumber = new BigInteger(bSign, bBytes);
264: BigInteger result = aNumber.subtract(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(1, result.signum());
271: }
272:
273: /**
274: * Subtract two numbers of the same length and different signs.
275: * The first is positive.
276: * The second is greater in absolute value.
277: */
278: public void testCase12() {
279: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
280: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
281: int aSign = 1;
282: int bSign = -1;
283: byte rBytes[] = { 1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15,
284: 26, 37 };
285: BigInteger aNumber = new BigInteger(aSign, aBytes);
286: BigInteger bNumber = new BigInteger(bSign, bBytes);
287: BigInteger result = aNumber.subtract(bNumber);
288: byte resBytes[] = new byte[rBytes.length];
289: resBytes = result.toByteArray();
290: for (int i = 0; i < resBytes.length; i++) {
291: assertTrue(resBytes[i] == rBytes[i]);
292: }
293: assertEquals(1, result.signum());
294: }
295:
296: /**
297: * Subtract two numbers of different length and different signs.
298: * The first is negative.
299: * The first is longer.
300: */
301: public void testCase13() {
302: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
303: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
304: int aSign = -1;
305: int bSign = 1;
306: byte rBytes[] = { -2, -3, -4, -5, -16, -27, -38, -42, -53, -64,
307: -75, -16, -27, -37 };
308: BigInteger aNumber = new BigInteger(aSign, aBytes);
309: BigInteger bNumber = new BigInteger(bSign, bBytes);
310: BigInteger result = aNumber.subtract(bNumber);
311: byte resBytes[] = new byte[rBytes.length];
312: resBytes = result.toByteArray();
313: for (int i = 0; i < resBytes.length; i++) {
314: assertTrue(resBytes[i] == rBytes[i]);
315: }
316: assertEquals(-1, result.signum());
317: }
318:
319: /**
320: * Subtract two numbers of the same length and different signs.
321: * The first is negative.
322: * The second is longer.
323: */
324: public void testCase14() {
325: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
326: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
327: int aSign = -1;
328: int bSign = 1;
329: byte rBytes[] = { -2, -3, -4, -5, -16, -27, -38, -42, -53, -64,
330: -75, -16, -27, -37 };
331: BigInteger aNumber = new BigInteger(aSign, aBytes);
332: BigInteger bNumber = new BigInteger(bSign, bBytes);
333: BigInteger result = aNumber.subtract(bNumber);
334: byte resBytes[] = new byte[rBytes.length];
335: resBytes = result.toByteArray();
336: for (int i = 0; i < resBytes.length; i++) {
337: assertTrue(resBytes[i] == rBytes[i]);
338: }
339: assertEquals(-1, result.signum());
340: }
341:
342: /**
343: * Subtract two negative numbers of different length.
344: * The first is longer.
345: */
346: public void testCase15() {
347: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
348: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
349: int aSign = -1;
350: int bSign = -1;
351: byte rBytes[] = { -2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5,
352: 14, 23 };
353: BigInteger aNumber = new BigInteger(aSign, aBytes);
354: BigInteger bNumber = new BigInteger(bSign, bBytes);
355: BigInteger result = aNumber.subtract(bNumber);
356: byte resBytes[] = new byte[rBytes.length];
357: resBytes = result.toByteArray();
358: for (int i = 0; i < resBytes.length; i++) {
359: assertTrue(resBytes[i] == rBytes[i]);
360: }
361: assertEquals(-1, result.signum());
362: }
363:
364: /**
365: * Subtract two negative numbers of different length.
366: * The second is longer.
367: */
368: public void testCase16() {
369: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
370: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7 };
371: int aSign = -1;
372: int bSign = -1;
373: byte rBytes[] = { 1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67,
374: -6, -15, -23 };
375: BigInteger aNumber = new BigInteger(aSign, aBytes);
376: BigInteger bNumber = new BigInteger(bSign, bBytes);
377: BigInteger result = aNumber.subtract(bNumber);
378: byte resBytes[] = new byte[rBytes.length];
379: resBytes = result.toByteArray();
380: for (int i = 0; i < resBytes.length; i++) {
381: assertTrue(resBytes[i] == rBytes[i]);
382: }
383: assertEquals(1, result.signum());
384: }
385:
386: /**
387: * Subtract two positive equal in absolute value numbers.
388: */
389: public void testCase17() {
390: byte aBytes[] = { -120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
391: byte bBytes[] = { -120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
392: byte rBytes[] = { 0 };
393: int aSign = 1;
394: int bSign = 1;
395: BigInteger aNumber = new BigInteger(aSign, aBytes);
396: BigInteger bNumber = new BigInteger(bSign, bBytes);
397: BigInteger result = aNumber.subtract(bNumber);
398: byte resBytes[] = new byte[rBytes.length];
399: resBytes = result.toByteArray();
400: for (int i = 0; i < resBytes.length; i++) {
401: assertTrue(resBytes[i] == rBytes[i]);
402: }
403: assertEquals(0, result.signum());
404: }
405:
406: /**
407: * Subtract zero from a number.
408: * The number is positive.
409: */
410: public void testCase18() {
411: byte aBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
412: byte bBytes[] = { 0 };
413: byte rBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
414: int aSign = 1;
415: int bSign = 0;
416: BigInteger aNumber = new BigInteger(aSign, aBytes);
417: BigInteger bNumber = new BigInteger(bSign, bBytes);
418: BigInteger result = aNumber.subtract(bNumber);
419: byte resBytes[] = new byte[rBytes.length];
420: resBytes = result.toByteArray();
421: for (int i = 0; i < resBytes.length; i++) {
422: assertTrue(resBytes[i] == rBytes[i]);
423: }
424: assertEquals(1, result.signum());
425: }
426:
427: /**
428: * Subtract a number from zero.
429: * The number is negative.
430: */
431: public void testCase19() {
432: byte aBytes[] = { 0 };
433: byte bBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
434: byte rBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
435: int aSign = 0;
436: int bSign = -1;
437: BigInteger aNumber = new BigInteger(aSign, aBytes);
438: BigInteger bNumber = new BigInteger(bSign, bBytes);
439: BigInteger result = aNumber.subtract(bNumber);
440: byte resBytes[] = new byte[rBytes.length];
441: resBytes = result.toByteArray();
442: for (int i = 0; i < resBytes.length; i++) {
443: assertTrue(resBytes[i] == rBytes[i]);
444: }
445: assertEquals(1, result.signum());
446: }
447:
448: /**
449: * Subtract zero from zero.
450: */
451: public void testCase20() {
452: byte aBytes[] = { 0 };
453: byte bBytes[] = { 0 };
454: byte rBytes[] = { 0 };
455: int aSign = 0;
456: int bSign = 0;
457: BigInteger aNumber = new BigInteger(aSign, aBytes);
458: BigInteger bNumber = new BigInteger(bSign, bBytes);
459: BigInteger result = aNumber.subtract(bNumber);
460: byte resBytes[] = new byte[rBytes.length];
461: resBytes = result.toByteArray();
462: for (int i = 0; i < resBytes.length; i++) {
463: assertTrue(resBytes[i] == rBytes[i]);
464: }
465: assertEquals(0, result.signum());
466: }
467:
468: /**
469: * Subtract ZERO from a number.
470: * The number is positive.
471: */
472: public void testCase21() {
473: byte aBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
474: byte rBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
475: int aSign = 1;
476: BigInteger aNumber = new BigInteger(aSign, aBytes);
477: BigInteger bNumber = BigInteger.ZERO;
478: BigInteger result = aNumber.subtract(bNumber);
479: byte resBytes[] = new byte[rBytes.length];
480: resBytes = result.toByteArray();
481: for (int i = 0; i < resBytes.length; i++) {
482: assertTrue(resBytes[i] == rBytes[i]);
483: }
484: assertEquals(1, result.signum());
485: }
486:
487: /**
488: * Subtract a number from ZERO.
489: * The number is negative.
490: */
491: public void testCase22() {
492: byte bBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
493: byte rBytes[] = { 120, 34, 78, -23, -111, 45, 127, 23, 45, -3 };
494: int bSign = -1;
495: BigInteger aNumber = BigInteger.ZERO;
496: BigInteger bNumber = new BigInteger(bSign, bBytes);
497: BigInteger result = aNumber.subtract(bNumber);
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(1, result.signum());
504: }
505:
506: /**
507: * Subtract ZERO from ZERO.
508: */
509: public void testCase23() {
510: byte rBytes[] = { 0 };
511: BigInteger aNumber = BigInteger.ZERO;
512: BigInteger bNumber = BigInteger.ZERO;
513: BigInteger result = aNumber.subtract(bNumber);
514: byte resBytes[] = new byte[rBytes.length];
515: resBytes = result.toByteArray();
516: for (int i = 0; i < resBytes.length; i++) {
517: assertTrue(resBytes[i] == rBytes[i]);
518: }
519: assertEquals(0, result.signum());
520: }
521:
522: /**
523: * Subtract ONE from ONE.
524: */
525: public void testCase24() {
526: byte rBytes[] = { 0 };
527: BigInteger aNumber = BigInteger.ONE;
528: BigInteger bNumber = BigInteger.ONE;
529: BigInteger result = aNumber.subtract(bNumber);
530: byte resBytes[] = new byte[rBytes.length];
531: resBytes = result.toByteArray();
532: for (int i = 0; i < resBytes.length; i++) {
533: assertTrue(resBytes[i] == rBytes[i]);
534: }
535: assertEquals(0, result.signum());
536: }
537:
538: /**
539: * Subtract two numbers so that borrow is 1.
540: */
541: public void testCase25() {
542: byte aBytes[] = { -1, -1, -1, -1, -1, -1, -1, -1 };
543: byte bBytes[] = { -128, -128, -128, -128, -128, -128, -128,
544: -128, -128 };
545: int aSign = 1;
546: int bSign = 1;
547: byte rBytes[] = { -128, 127, 127, 127, 127, 127, 127, 127, 127 };
548: BigInteger aNumber = new BigInteger(aSign, aBytes);
549: BigInteger bNumber = new BigInteger(bSign, bBytes);
550: BigInteger result = aNumber.subtract(bNumber);
551: byte resBytes[] = new byte[rBytes.length];
552: resBytes = result.toByteArray();
553: for (int i = 0; i < resBytes.length; i++) {
554: assertTrue(resBytes[i] == rBytes[i]);
555: }
556: assertEquals(-1, result.signum());
557: }
558: }
|