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: multiply
028: */
029: public class BigIntegerMultiplyTest extends TestCase {
030: /**
031: * Multiply two negative numbers of the same length
032: */
033: public void testCase1() {
034: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3 };
035: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
036: int aSign = -1;
037: int bSign = -1;
038: byte rBytes[] = { 10, 40, 100, -55, 96, 51, 76, 40, -45, 85,
039: 105, 4, 28, -86, -117, -52, 100, 120, 90 };
040: BigInteger aNumber = new BigInteger(aSign, aBytes);
041: BigInteger bNumber = new BigInteger(bSign, bBytes);
042: BigInteger result = aNumber.multiply(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("incorrect sign", 1, result.signum());
049: }
050:
051: /**
052: * Multiply two numbers of the same length and different signs.
053: * The first is negative.
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[] = { -11, -41, -101, 54, -97, -52, -77, -41, 44,
061: -86, -106, -5, -29, 85, 116, 51, -101, -121, -90 };
062: BigInteger aNumber = new BigInteger(aSign, aBytes);
063: BigInteger bNumber = new BigInteger(bSign, bBytes);
064: BigInteger result = aNumber.multiply(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("incorrect sign", -1, result.signum());
071: }
072:
073: /**
074: * Multiply two positive numbers of different length.
075: * The first is longer.
076: */
077: public void testCase3() {
078: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
079: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
080: int aSign = 1;
081: int bSign = 1;
082: byte rBytes[] = { 10, 40, 100, -55, 96, 51, 76, 40, -45, 85,
083: 115, 44, -127, 115, -21, -62, -15, 85, 64, -87, -2,
084: -36, -36, -106 };
085: BigInteger aNumber = new BigInteger(aSign, aBytes);
086: BigInteger bNumber = new BigInteger(bSign, bBytes);
087: BigInteger result = aNumber.multiply(bNumber);
088: byte resBytes[] = new byte[rBytes.length];
089: resBytes = result.toByteArray();
090: for (int i = 0; i < resBytes.length; i++) {
091: assertTrue(resBytes[i] == rBytes[i]);
092: }
093: assertEquals("incorrect sign", 1, result.signum());
094: }
095:
096: /**
097: * Multiply two positive numbers of different length.
098: * The second is longer.
099: */
100: public void testCase4() {
101: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
102: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
103: int aSign = 1;
104: int bSign = 1;
105: byte rBytes[] = { 10, 40, 100, -55, 96, 51, 76, 40, -45, 85,
106: 115, 44, -127, 115, -21, -62, -15, 85, 64, -87, -2,
107: -36, -36, -106 };
108: BigInteger aNumber = new BigInteger(aSign, aBytes);
109: BigInteger bNumber = new BigInteger(bSign, bBytes);
110: BigInteger result = aNumber.multiply(bNumber);
111: byte resBytes[] = new byte[rBytes.length];
112: resBytes = result.toByteArray();
113: for (int i = 0; i < resBytes.length; i++) {
114: assertTrue(resBytes[i] == rBytes[i]);
115: }
116: assertEquals("incorrect sign", 1, result.signum());
117: }
118:
119: /**
120: * Multiply two numbers of different length and different signs.
121: * The first is positive.
122: * The first is longer.
123: */
124: public void testCase5() {
125: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
126: byte bBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
127: int aSign = 1;
128: int bSign = -1;
129: byte rBytes[] = { -11, -41, -101, 54, -97, -52, -77, -41, 44,
130: -86, -116, -45, 126, -116, 20, 61, 14, -86, -65, 86, 1,
131: 35, 35, 106 };
132: BigInteger aNumber = new BigInteger(aSign, aBytes);
133: BigInteger bNumber = new BigInteger(bSign, bBytes);
134: BigInteger result = aNumber.multiply(bNumber);
135: byte resBytes[] = new byte[rBytes.length];
136: resBytes = result.toByteArray();
137: for (int i = 0; i < resBytes.length; i++) {
138: assertTrue(resBytes[i] == rBytes[i]);
139: }
140: assertEquals("incorrect sign", -1, result.signum());
141: }
142:
143: /**
144: * Multiply two numbers of different length and different signs.
145: * The first is positive.
146: * The second is longer.
147: */
148: public void testCase6() {
149: byte aBytes[] = { 10, 20, 30, 40, 50, 60, 70, 10, 20, 30 };
150: byte bBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
151: int aSign = 1;
152: int bSign = -1;
153: byte rBytes[] = { -11, -41, -101, 54, -97, -52, -77, -41, 44,
154: -86, -116, -45, 126, -116, 20, 61, 14, -86, -65, 86, 1,
155: 35, 35, 106 };
156: BigInteger aNumber = new BigInteger(aSign, aBytes);
157: BigInteger bNumber = new BigInteger(bSign, bBytes);
158: BigInteger result = aNumber.multiply(bNumber);
159: byte resBytes[] = new byte[rBytes.length];
160: resBytes = result.toByteArray();
161: for (int i = 0; i < resBytes.length; i++) {
162: assertTrue(resBytes[i] == rBytes[i]);
163: }
164: assertEquals("incorrect sign", -1, result.signum());
165: }
166:
167: /**
168: * Multiply a number by zero.
169: */
170: public void testCase7() {
171: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
172: byte bBytes[] = { 0 };
173: int aSign = 1;
174: int bSign = 0;
175: byte rBytes[] = { 0 };
176: BigInteger aNumber = new BigInteger(aSign, aBytes);
177: BigInteger bNumber = new BigInteger(bSign, bBytes);
178: BigInteger result = aNumber.multiply(bNumber);
179: byte resBytes[] = new byte[rBytes.length];
180: resBytes = result.toByteArray();
181: for (int i = 0; i < resBytes.length; i++) {
182: assertTrue(resBytes[i] == rBytes[i]);
183: }
184: assertEquals("incorrect sign", 0, result.signum());
185: }
186:
187: /**
188: * Multiply a number by ZERO.
189: */
190: public void testCase8() {
191: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
192: int aSign = 1;
193: byte rBytes[] = { 0 };
194: BigInteger aNumber = new BigInteger(aSign, aBytes);
195: BigInteger bNumber = BigInteger.ZERO;
196: BigInteger result = aNumber.multiply(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", 0, result.signum());
203: }
204:
205: /**
206: * Multiply a positive number by ONE.
207: */
208: public void testCase9() {
209: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
210: int aSign = 1;
211: byte rBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
212: BigInteger aNumber = new BigInteger(aSign, aBytes);
213: BigInteger bNumber = BigInteger.ONE;
214: BigInteger result = aNumber.multiply(bNumber);
215: byte resBytes[] = new byte[rBytes.length];
216: resBytes = result.toByteArray();
217: for (int i = 0; i < resBytes.length; i++) {
218: assertTrue(resBytes[i] == rBytes[i]);
219: }
220: assertEquals("incorrect sign", 1, result.signum());
221: }
222:
223: /**
224: * Multiply a negative number by ONE.
225: */
226: public void testCase10() {
227: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5 };
228: int aSign = -1;
229: byte rBytes[] = { -2, -3, -4, -5, -6, -7, -8, -2, -3, -4, -2,
230: -3, -4, -5, -5 };
231: BigInteger aNumber = new BigInteger(aSign, aBytes);
232: BigInteger bNumber = BigInteger.ONE;
233: BigInteger result = aNumber.multiply(bNumber);
234: byte resBytes[] = new byte[rBytes.length];
235: resBytes = result.toByteArray();
236: for (int i = 0; i < resBytes.length; i++) {
237: assertTrue(resBytes[i] == rBytes[i]);
238: }
239: assertEquals("incorrect sign", -1, result.signum());
240: }
241:
242: /**
243: * Multiply two numbers of 4 bytes length.
244: */
245: public void testIntbyInt1() {
246: byte aBytes[] = { 10, 20, 30, 40 };
247: byte bBytes[] = { 1, 2, 3, 4 };
248: int aSign = 1;
249: int bSign = -1;
250: byte rBytes[] = { -11, -41, -101, 55, 5, 15, 96 };
251: BigInteger aNumber = new BigInteger(aSign, aBytes);
252: BigInteger bNumber = new BigInteger(bSign, bBytes);
253: BigInteger result = aNumber.multiply(bNumber);
254: byte resBytes[] = new byte[rBytes.length];
255: resBytes = result.toByteArray();
256: for (int i = 0; i < resBytes.length; i++) {
257: assertTrue(resBytes[i] == rBytes[i]);
258: }
259: assertEquals("incorrect sign", -1, result.signum());
260: }
261:
262: /**
263: * Multiply two numbers of 4 bytes length.
264: */
265: public void testIntbyInt2() {
266: byte aBytes[] = { -1, -1, -1, -1 };
267: byte bBytes[] = { -1, -1, -1, -1 };
268: int aSign = 1;
269: int bSign = 1;
270: byte rBytes[] = { 0, -1, -1, -1, -2, 0, 0, 0, 1 };
271: BigInteger aNumber = new BigInteger(aSign, aBytes);
272: BigInteger bNumber = new BigInteger(bSign, bBytes);
273: BigInteger result = aNumber.multiply(bNumber);
274: byte resBytes[] = new byte[rBytes.length];
275: resBytes = result.toByteArray();
276: for (int i = 0; i < resBytes.length; i++) {
277: assertTrue(resBytes[i] == rBytes[i]);
278: }
279: assertEquals("incorrect sign", 1, result.signum());
280: }
281:
282: /**
283: * Negative exponent.
284: */
285: public void testPowException() {
286: byte aBytes[] = { 1, 2, 3, 4, 5, 6, 7 };
287: int aSign = 1;
288: int exp = -5;
289: BigInteger aNumber = new BigInteger(aSign, aBytes);
290: try {
291: aNumber.pow(exp);
292: fail("ArithmeticException has not been caught");
293: } catch (ArithmeticException e) {
294: assertEquals("Improper exception message",
295: "Negative exponent", e.getMessage());
296: }
297: }
298:
299: /**
300: * Exponentiation of a negative number to an odd exponent.
301: */
302: public void testPowNegativeNumToOddExp() {
303: byte aBytes[] = { 50, -26, 90, 69, 120, 32, 63, -103, -14, 35 };
304: int aSign = -1;
305: int exp = 5;
306: byte rBytes[] = { -21, -94, -42, -15, -127, 113, -50, -88, 115,
307: -35, 3, 59, -92, 111, -75, 103, -42, 41, 34, -114, 99,
308: -32, 105, -59, 127, 45, 108, 74, -93, 105, 33, 12, -5,
309: -20, 17, -21, -119, -127, -115, 27, -122, 26, -67, 109,
310: -125, 16, 91, -70, 109 };
311: BigInteger aNumber = new BigInteger(aSign, aBytes);
312: BigInteger result = aNumber.pow(exp);
313: byte resBytes[] = new byte[rBytes.length];
314: resBytes = result.toByteArray();
315: for (int i = 0; i < resBytes.length; i++) {
316: assertTrue(resBytes[i] == rBytes[i]);
317: }
318: assertEquals("incorrect sign", -1, result.signum());
319: }
320:
321: /**
322: * Exponentiation of a negative number to an even exponent.
323: */
324: public void testPowNegativeNumToEvenExp() {
325: byte aBytes[] = { 50, -26, 90, 69, 120, 32, 63, -103, -14, 35 };
326: int aSign = -1;
327: int exp = 4;
328: byte rBytes[] = { 102, 107, -122, -43, -52, -20, -27, 25, -9,
329: 88, -13, 75, 78, 81, -33, -77, 39, 27, -37, 106, 121,
330: -73, 108, -47, -101, 80, -25, 71, 13, 94, -7, -33, 1,
331: -17, -65, -70, -61, -3, -47 };
332: BigInteger aNumber = new BigInteger(aSign, aBytes);
333: BigInteger result = aNumber.pow(exp);
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("incorrect sign", 1, result.signum());
340: }
341:
342: /**
343: * Exponentiation of a negative number to zero exponent.
344: */
345: public void testPowNegativeNumToZeroExp() {
346: byte aBytes[] = { 50, -26, 90, 69, 120, 32, 63, -103, -14, 35 };
347: int aSign = -1;
348: int exp = 0;
349: byte rBytes[] = { 1 };
350: BigInteger aNumber = new BigInteger(aSign, aBytes);
351: BigInteger result = aNumber.pow(exp);
352: byte resBytes[] = new byte[rBytes.length];
353: resBytes = result.toByteArray();
354: for (int i = 0; i < resBytes.length; i++) {
355: assertTrue(resBytes[i] == rBytes[i]);
356: }
357: assertEquals("incorrect sign", 1, result.signum());
358: }
359:
360: /**
361: * Exponentiation of a positive number.
362: */
363: public void testPowPositiveNum() {
364: byte aBytes[] = { 50, -26, 90, 69, 120, 32, 63, -103, -14, 35 };
365: int aSign = 1;
366: int exp = 5;
367: byte rBytes[] = { 20, 93, 41, 14, 126, -114, 49, 87, -116, 34,
368: -4, -60, 91, -112, 74, -104, 41, -42, -35, 113, -100,
369: 31, -106, 58, -128, -46, -109, -75, 92, -106, -34, -13,
370: 4, 19, -18, 20, 118, 126, 114, -28, 121, -27, 66, -110,
371: 124, -17, -92, 69, -109 };
372: BigInteger aNumber = new BigInteger(aSign, aBytes);
373: BigInteger result = aNumber.pow(exp);
374: byte resBytes[] = new byte[rBytes.length];
375: resBytes = result.toByteArray();
376: for (int i = 0; i < resBytes.length; i++) {
377: assertTrue(resBytes[i] == rBytes[i]);
378: }
379: assertEquals("incorrect sign", 1, result.signum());
380: }
381:
382: /**
383: * Exponentiation of a negative number to zero exponent.
384: */
385: public void testPowPositiveNumToZeroExp() {
386: byte aBytes[] = { 50, -26, 90, 69, 120, 32, 63, -103, -14, 35 };
387: int aSign = 1;
388: int exp = 0;
389: byte rBytes[] = { 1 };
390: BigInteger aNumber = new BigInteger(aSign, aBytes);
391: BigInteger result = aNumber.pow(exp);
392: byte resBytes[] = new byte[rBytes.length];
393: resBytes = result.toByteArray();
394: for (int i = 0; i < resBytes.length; i++) {
395: assertTrue(resBytes[i] == rBytes[i]);
396: }
397: assertEquals("incorrect sign", 1, result.signum());
398: }
399: }
|