0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one or more
0003: * contributor license agreements. See the NOTICE file distributed with
0004: * this work for additional information regarding copyright ownership.
0005: * The ASF licenses this file to You under the Apache License, Version 2.0
0006: * (the "License"); you may not use this file except in compliance with
0007: * the License. You may obtain a copy of the License at
0008: *
0009: * http://www.apache.org/licenses/LICENSE-2.0
0010: *
0011: * Unless required by applicable law or agreed to in writing, software
0012: * distributed under the License is distributed on an "AS IS" BASIS,
0013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014: * See the License for the specific language governing permissions and
0015: * limitations under the License.
0016: */
0017: /**
0018: * @author Elena Semukhina
0019: * @version $Revision$
0020: */package org.apache.harmony.tests.java.math;
0021:
0022: import junit.framework.TestCase;
0023: import java.math.BigInteger;
0024:
0025: /**
0026: * Class: java.math.BigInteger
0027: * Methods: bitLength, shiftLeft, shiftRight,
0028: * clearBit, flipBit, setBit, testBit
0029: */
0030: public class BigIntegerOperateBitsTest extends TestCase {
0031: /**
0032: * bitCount() of zero.
0033: */
0034: public void testBitCountZero() {
0035: BigInteger aNumber = new BigInteger("0");
0036: assertEquals(0, aNumber.bitCount());
0037: }
0038:
0039: /**
0040: * bitCount() of a negative number.
0041: */
0042: public void testBitCountNeg() {
0043: BigInteger aNumber = new BigInteger(
0044: "-12378634756382937873487638746283767238657872368748726875");
0045: assertEquals(87, aNumber.bitCount());
0046: }
0047:
0048: /**
0049: * bitCount() of a negative number.
0050: */
0051: public void testBitCountPos() {
0052: BigInteger aNumber = new BigInteger(
0053: "12378634756343564757582937873487638746283767238657872368748726875");
0054: assertEquals(107, aNumber.bitCount());
0055: }
0056:
0057: /**
0058: * bitLength() of zero.
0059: */
0060: public void testBitLengthZero() {
0061: BigInteger aNumber = new BigInteger("0");
0062: assertEquals(0, aNumber.bitLength());
0063: }
0064:
0065: /**
0066: * bitLength() of a positive number.
0067: */
0068: public void testBitLengthPositive1() {
0069: byte aBytes[] = { 12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35,
0070: 26, 3, 91 };
0071: int aSign = 1;
0072: BigInteger aNumber = new BigInteger(aSign, aBytes);
0073: assertEquals(108, aNumber.bitLength());
0074: }
0075:
0076: /**
0077: * bitLength() of a positive number with the leftmost bit set
0078: */
0079: public void testBitLengthPositive2() {
0080: byte aBytes[] = { -128, 56, 100, -2, -76, 89, 45, 91, 3, -15,
0081: 35, 26 };
0082: int aSign = 1;
0083: BigInteger aNumber = new BigInteger(aSign, aBytes);
0084: assertEquals(96, aNumber.bitLength());
0085: }
0086:
0087: /**
0088: * bitLength() of a positive number which is a power of 2
0089: */
0090: public void testBitLengthPositive3() {
0091: byte aBytes[] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
0092: int aSign = 1;
0093: BigInteger aNumber = new BigInteger(aSign, aBytes);
0094: assertEquals(81, aNumber.bitLength());
0095: }
0096:
0097: /**
0098: * bitLength() of a negative number.
0099: */
0100: public void testBitLengthNegative1() {
0101: byte aBytes[] = { 12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35,
0102: 26, 3, 91 };
0103: int aSign = -1;
0104: BigInteger aNumber = new BigInteger(aSign, aBytes);
0105: assertEquals(108, aNumber.bitLength());
0106: }
0107:
0108: /**
0109: * bitLength() of a negative number with the leftmost bit set
0110: */
0111: public void testBitLengthNegative2() {
0112: byte aBytes[] = { -128, 56, 100, -2, -76, 89, 45, 91, 3, -15,
0113: 35, 26 };
0114: int aSign = -1;
0115: BigInteger aNumber = new BigInteger(aSign, aBytes);
0116: assertEquals(96, aNumber.bitLength());
0117: }
0118:
0119: /**
0120: * bitLength() of a negative number which is a power of 2
0121: */
0122: public void testBitLengthNegative3() {
0123: byte aBytes[] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
0124: int aSign = -1;
0125: BigInteger aNumber = new BigInteger(aSign, aBytes);
0126: assertEquals(80, aNumber.bitLength());
0127: }
0128:
0129: /**
0130: * clearBit(int n) of a negative n
0131: */
0132: public void testClearBitException() {
0133: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0134: -15, 35, 26 };
0135: int aSign = 1;
0136: int number = -7;
0137: BigInteger aNumber = new BigInteger(aSign, aBytes);
0138: try {
0139: aNumber.clearBit(number);
0140: fail("ArithmeticException has not been caught");
0141: } catch (ArithmeticException e) {
0142: assertEquals("Improper exception message",
0143: "Negative bit address", e.getMessage());
0144: }
0145: }
0146:
0147: /**
0148: * clearBit(int n) outside zero
0149: */
0150: public void testClearBitZero() {
0151: byte aBytes[] = { 0 };
0152: int aSign = 0;
0153: int number = 0;
0154: byte rBytes[] = { 0 };
0155: BigInteger aNumber = new BigInteger(aSign, aBytes);
0156: BigInteger result = aNumber.clearBit(number);
0157: byte resBytes[] = new byte[rBytes.length];
0158: resBytes = result.toByteArray();
0159: for (int i = 0; i < resBytes.length; i++) {
0160: assertTrue(resBytes[i] == rBytes[i]);
0161: }
0162: assertEquals("incorrect sign", 0, result.signum());
0163: }
0164:
0165: /**
0166: * clearBit(int n) outside zero
0167: */
0168: public void testClearBitZeroOutside1() {
0169: byte aBytes[] = { 0 };
0170: int aSign = 0;
0171: int number = 95;
0172: byte rBytes[] = { 0 };
0173: BigInteger aNumber = new BigInteger(aSign, aBytes);
0174: BigInteger result = aNumber.clearBit(number);
0175: byte resBytes[] = new byte[rBytes.length];
0176: resBytes = result.toByteArray();
0177: for (int i = 0; i < resBytes.length; i++) {
0178: assertTrue(resBytes[i] == rBytes[i]);
0179: }
0180: assertEquals("incorrect sign", 0, result.signum());
0181: }
0182:
0183: /**
0184: * clearBit(int n) inside a negative number
0185: */
0186: public void testClearBitNegativeInside1() {
0187: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0188: -15, 35, 26 };
0189: int aSign = -1;
0190: int number = 15;
0191: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
0192: 14, 92, -26 };
0193: BigInteger aNumber = new BigInteger(aSign, aBytes);
0194: BigInteger result = aNumber.clearBit(number);
0195: byte resBytes[] = new byte[rBytes.length];
0196: resBytes = result.toByteArray();
0197: for (int i = 0; i < resBytes.length; i++) {
0198: assertTrue(resBytes[i] == rBytes[i]);
0199: }
0200: assertEquals("incorrect sign", -1, result.signum());
0201: }
0202:
0203: /**
0204: * clearBit(int n) inside a negative number
0205: */
0206: public void testClearBitNegativeInside2() {
0207: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0208: -15, 35, 26 };
0209: int aSign = -1;
0210: int number = 44;
0211: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -62, -92, -4,
0212: 14, -36, -26 };
0213: BigInteger aNumber = new BigInteger(aSign, aBytes);
0214: BigInteger result = aNumber.clearBit(number);
0215: byte resBytes[] = new byte[rBytes.length];
0216: resBytes = result.toByteArray();
0217: for (int i = 0; i < resBytes.length; i++) {
0218: assertTrue(resBytes[i] == rBytes[i]);
0219: }
0220: assertEquals("incorrect sign", -1, result.signum());
0221: }
0222:
0223: /**
0224: * clearBit(2) in the negative number with all ones in bit representation
0225: */
0226: public void testClearBitNegativeInside3() {
0227: String as = "-18446744073709551615";
0228: int number = 2;
0229: BigInteger aNumber = new BigInteger(as);
0230: BigInteger result = aNumber.clearBit(number);
0231: assertEquals(as, result.toString());
0232: }
0233:
0234: /**
0235: * clearBit(0) in the negative number of length 1
0236: * with all ones in bit representation.
0237: * the resulting number's length is 2.
0238: */
0239: public void testClearBitNegativeInside4() {
0240: String as = "-4294967295";
0241: String res = "-4294967296";
0242: int number = 0;
0243: BigInteger aNumber = new BigInteger(as);
0244: BigInteger result = aNumber.clearBit(number);
0245: assertEquals(res, result.toString());
0246: }
0247:
0248: /**
0249: * clearBit(0) in the negative number of length 2
0250: * with all ones in bit representation.
0251: * the resulting number's length is 3.
0252: */
0253: public void testClearBitNegativeInside5() {
0254: String as = "-18446744073709551615";
0255: String res = "-18446744073709551616";
0256: int number = 0;
0257: BigInteger aNumber = new BigInteger(as);
0258: BigInteger result = aNumber.clearBit(number);
0259: assertEquals(res, result.toString());
0260: }
0261:
0262: /**
0263: * clearBit(int n) outside a negative number
0264: */
0265: public void testClearBitNegativeOutside1() {
0266: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0267: -15, 35, 26 };
0268: int aSign = -1;
0269: int number = 150;
0270: byte rBytes[] = { -65, -1, -1, -1, -1, -1, -2, 127, -57, -101,
0271: 1, 75, -90, -46, -92, -4, 14, -36, -26 };
0272: BigInteger aNumber = new BigInteger(aSign, aBytes);
0273: BigInteger result = aNumber.clearBit(number);
0274: byte resBytes[] = new byte[rBytes.length];
0275: resBytes = result.toByteArray();
0276: for (int i = 0; i < resBytes.length; i++) {
0277: assertTrue(resBytes[i] == rBytes[i]);
0278: }
0279: assertEquals("incorrect sign", -1, result.signum());
0280: }
0281:
0282: /**
0283: * clearBit(int n) outside a negative number
0284: */
0285: public void testClearBitNegativeOutside2() {
0286: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0287: -15, 35, 26 };
0288: int aSign = -1;
0289: int number = 165;
0290: byte rBytes[] = { -33, -1, -1, -1, -1, -1, -1, -1, -2, 127,
0291: -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26 };
0292: BigInteger aNumber = new BigInteger(aSign, aBytes);
0293: BigInteger result = aNumber.clearBit(number);
0294: byte resBytes[] = new byte[rBytes.length];
0295: resBytes = result.toByteArray();
0296: for (int i = 0; i < resBytes.length; i++) {
0297: assertTrue(resBytes[i] == rBytes[i]);
0298: }
0299: assertEquals("incorrect sign", -1, result.signum());
0300: }
0301:
0302: /**
0303: * clearBit(int n) inside a positive number
0304: */
0305: public void testClearBitPositiveInside1() {
0306: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0307: -15, 35, 26 };
0308: int aSign = 1;
0309: int number = 20;
0310: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0311: -31, 35, 26 };
0312: BigInteger aNumber = new BigInteger(aSign, aBytes);
0313: BigInteger result = aNumber.clearBit(number);
0314: byte resBytes[] = new byte[rBytes.length];
0315: resBytes = result.toByteArray();
0316: for (int i = 0; i < resBytes.length; i++) {
0317: assertTrue(resBytes[i] == rBytes[i]);
0318: }
0319: assertEquals("incorrect sign", 1, result.signum());
0320: }
0321:
0322: /**
0323: * clearBit(int n) inside a positive number
0324: */
0325: public void testClearBitPositiveInside2() {
0326: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0327: -15, 35, 26 };
0328: int aSign = 1;
0329: int number = 17;
0330: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0331: -15, 35, 26 };
0332: BigInteger aNumber = new BigInteger(aSign, aBytes);
0333: BigInteger result = aNumber.clearBit(number);
0334: byte resBytes[] = new byte[rBytes.length];
0335: resBytes = result.toByteArray();
0336: for (int i = 0; i < resBytes.length; i++) {
0337: assertTrue(resBytes[i] == rBytes[i]);
0338: }
0339: assertEquals("incorrect sign", 1, result.signum());
0340: }
0341:
0342: /**
0343: * clearBit(int n) inside a positive number
0344: */
0345: public void testClearBitPositiveInside3() {
0346: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0347: -15, 35, 26 };
0348: int aSign = 1;
0349: int number = 45;
0350: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 13, 91, 3,
0351: -15, 35, 26 };
0352: BigInteger aNumber = new BigInteger(aSign, aBytes);
0353: BigInteger result = aNumber.clearBit(number);
0354: byte resBytes[] = new byte[rBytes.length];
0355: resBytes = result.toByteArray();
0356: for (int i = 0; i < resBytes.length; i++) {
0357: assertTrue(resBytes[i] == rBytes[i]);
0358: }
0359: assertEquals("incorrect sign", 1, result.signum());
0360: }
0361:
0362: /**
0363: * clearBit(int n) inside a positive number
0364: */
0365: public void testClearBitPositiveInside4() {
0366: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0367: -15, 35, 26 };
0368: int aSign = 1;
0369: int number = 50;
0370: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0371: -15, 35, 26 };
0372: BigInteger aNumber = new BigInteger(aSign, aBytes);
0373: BigInteger result = aNumber.clearBit(number);
0374: byte resBytes[] = new byte[rBytes.length];
0375: resBytes = result.toByteArray();
0376: for (int i = 0; i < resBytes.length; i++) {
0377: assertTrue(resBytes[i] == rBytes[i]);
0378: }
0379: assertEquals("incorrect sign", 1, result.signum());
0380: }
0381:
0382: /**
0383: * clearBit(int n) inside a positive number
0384: */
0385: public void testClearBitPositiveInside5() {
0386: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0387: -15, 35, 26 };
0388: int aSign = 1;
0389: int number = 63;
0390: byte rBytes[] = { 1, -128, 56, 100, -2, 52, 89, 45, 91, 3, -15,
0391: 35, 26 };
0392: BigInteger aNumber = new BigInteger(aSign, aBytes);
0393: BigInteger result = aNumber.clearBit(number);
0394: byte resBytes[] = new byte[rBytes.length];
0395: resBytes = result.toByteArray();
0396: for (int i = 0; i < resBytes.length; i++) {
0397: assertTrue(resBytes[i] == rBytes[i]);
0398: }
0399: assertEquals("incorrect sign", 1, result.signum());
0400: }
0401:
0402: /**
0403: * clearBit(int n) outside a positive number
0404: */
0405: public void testClearBitPositiveOutside1() {
0406: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0407: -15, 35, 26 };
0408: int aSign = 1;
0409: int number = 150;
0410: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0411: -15, 35, 26 };
0412: BigInteger aNumber = new BigInteger(aSign, aBytes);
0413: BigInteger result = aNumber.clearBit(number);
0414: byte resBytes[] = new byte[rBytes.length];
0415: resBytes = result.toByteArray();
0416: for (int i = 0; i < resBytes.length; i++) {
0417: assertTrue(resBytes[i] == rBytes[i]);
0418: }
0419: assertEquals("incorrect sign", 1, result.signum());
0420: }
0421:
0422: /**
0423: * clearBit(int n) outside a positive number
0424: */
0425: public void testClearBitPositiveOutside2() {
0426: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0427: -15, 35, 26 };
0428: int aSign = 1;
0429: int number = 191;
0430: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0431: -15, 35, 26 };
0432: BigInteger aNumber = new BigInteger(aSign, aBytes);
0433: BigInteger result = aNumber.clearBit(number);
0434: byte resBytes[] = new byte[rBytes.length];
0435: resBytes = result.toByteArray();
0436: for (int i = 0; i < resBytes.length; i++) {
0437: assertTrue(resBytes[i] == rBytes[i]);
0438: }
0439: assertEquals("incorrect sign", 1, result.signum());
0440: }
0441:
0442: /**
0443: * clearBit(int n) the leftmost bit in a negative number
0444: */
0445: public void testClearBitTopNegative() {
0446: byte aBytes[] = { 1, -128, 56, 100, -15, 35, 26 };
0447: int aSign = -1;
0448: int number = 63;
0449: byte rBytes[] = { -1, 127, -2, 127, -57, -101, 14, -36, -26 };
0450: BigInteger aNumber = new BigInteger(aSign, aBytes);
0451: BigInteger result = aNumber.clearBit(number);
0452: byte resBytes[] = new byte[rBytes.length];
0453: resBytes = result.toByteArray();
0454: for (int i = 0; i < resBytes.length; i++) {
0455: assertTrue(resBytes[i] == rBytes[i]);
0456: }
0457: assertEquals("incorrect sign", -1, result.signum());
0458: }
0459:
0460: /**
0461: * flipBit(int n) of a negative n
0462: */
0463: public void testFlipBitException() {
0464: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0465: -15, 35, 26 };
0466: int aSign = 1;
0467: int number = -7;
0468: BigInteger aNumber = new BigInteger(aSign, aBytes);
0469: try {
0470: aNumber.flipBit(number);
0471: fail("ArithmeticException has not been caught");
0472: } catch (ArithmeticException e) {
0473: assertEquals("Improper exception message",
0474: "Negative bit address", e.getMessage());
0475: }
0476: }
0477:
0478: /**
0479: * flipBit(int n) zero
0480: */
0481: public void testFlipBitZero() {
0482: byte aBytes[] = { 0 };
0483: int aSign = 0;
0484: int number = 0;
0485: byte rBytes[] = { 1 };
0486: BigInteger aNumber = new BigInteger(aSign, aBytes);
0487: BigInteger result = aNumber.flipBit(number);
0488: byte resBytes[] = new byte[rBytes.length];
0489: resBytes = result.toByteArray();
0490: for (int i = 0; i < resBytes.length; i++) {
0491: assertTrue(resBytes[i] == rBytes[i]);
0492: }
0493: assertEquals("incorrect sign", 1, result.signum());
0494: }
0495:
0496: /**
0497: * flipBit(int n) outside zero
0498: */
0499: public void testFlipBitZeroOutside1() {
0500: byte aBytes[] = { 0 };
0501: int aSign = 0;
0502: int number = 62;
0503: byte rBytes[] = { 64, 0, 0, 0, 0, 0, 0, 0 };
0504: BigInteger aNumber = new BigInteger(aSign, aBytes);
0505: BigInteger result = aNumber.flipBit(number);
0506: byte resBytes[] = new byte[rBytes.length];
0507: resBytes = result.toByteArray();
0508: for (int i = 0; i < resBytes.length; i++) {
0509: assertTrue("incorrect value", resBytes[i] == rBytes[i]);
0510: }
0511: assertEquals("incorrect sign", 1, result.signum());
0512: }
0513:
0514: /**
0515: * flipBit(int n) outside zero
0516: */
0517: public void testFlipBitZeroOutside2() {
0518: byte aBytes[] = { 0 };
0519: int aSign = 0;
0520: int number = 63;
0521: byte rBytes[] = { 0, -128, 0, 0, 0, 0, 0, 0, 0 };
0522: BigInteger aNumber = new BigInteger(aSign, aBytes);
0523: BigInteger result = aNumber.flipBit(number);
0524: byte resBytes[] = new byte[rBytes.length];
0525: resBytes = result.toByteArray();
0526: for (int i = 0; i < resBytes.length; i++) {
0527: assertTrue("incorrect value", resBytes[i] == rBytes[i]);
0528: }
0529: assertEquals("incorrect sign", 1, result.signum());
0530: }
0531:
0532: /**
0533: * flipBit(int n) the leftmost bit in a negative number
0534: */
0535: public void testFlipBitLeftmostNegative() {
0536: byte aBytes[] = { 1, -128, 56, 100, -15, 35, 26 };
0537: int aSign = -1;
0538: int number = 48;
0539: byte rBytes[] = { -1, 127, -57, -101, 14, -36, -26, 49 };
0540: BigInteger aNumber = new BigInteger(aSign, aBytes);
0541: BigInteger result = aNumber.flipBit(number);
0542: byte resBytes[] = new byte[rBytes.length];
0543: resBytes = result.toByteArray();
0544: for (int i = 0; i < resBytes.length; i++) {
0545: assertTrue(resBytes[i] == rBytes[i]);
0546: }
0547: assertEquals("incorrect sign", -1, result.signum());
0548: }
0549:
0550: /**
0551: * flipBit(int n) the leftmost bit in a positive number
0552: */
0553: public void testFlipBitLeftmostPositive() {
0554: byte aBytes[] = { 1, -128, 56, 100, -15, 35, 26 };
0555: int aSign = 1;
0556: int number = 48;
0557: byte rBytes[] = { 0, -128, 56, 100, -15, 35, 26 };
0558: BigInteger aNumber = new BigInteger(aSign, aBytes);
0559: BigInteger result = aNumber.flipBit(number);
0560: byte resBytes[] = new byte[rBytes.length];
0561: resBytes = result.toByteArray();
0562: for (int i = 0; i < resBytes.length; i++) {
0563: assertTrue(resBytes[i] == rBytes[i]);
0564: }
0565: assertEquals("incorrect sign", 1, result.signum());
0566: }
0567:
0568: /**
0569: * flipBit(int n) inside a negative number
0570: */
0571: public void testFlipBitNegativeInside1() {
0572: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0573: -15, 35, 26 };
0574: int aSign = -1;
0575: int number = 15;
0576: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
0577: 14, 92, -26 };
0578: BigInteger aNumber = new BigInteger(aSign, aBytes);
0579: BigInteger result = aNumber.flipBit(number);
0580: byte resBytes[] = new byte[rBytes.length];
0581: resBytes = result.toByteArray();
0582: for (int i = 0; i < resBytes.length; i++) {
0583: assertTrue(resBytes[i] == rBytes[i]);
0584: }
0585: assertEquals("incorrect sign", -1, result.signum());
0586: }
0587:
0588: /**
0589: * flipBit(int n) inside a negative number
0590: */
0591: public void testFlipBitNegativeInside2() {
0592: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0593: -15, 35, 26 };
0594: int aSign = -1;
0595: int number = 45;
0596: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -14, -92, -4,
0597: 14, -36, -26 };
0598: BigInteger aNumber = new BigInteger(aSign, aBytes);
0599: BigInteger result = aNumber.flipBit(number);
0600: byte resBytes[] = new byte[rBytes.length];
0601: resBytes = result.toByteArray();
0602: for (int i = 0; i < resBytes.length; i++) {
0603: assertTrue(resBytes[i] == rBytes[i]);
0604: }
0605: assertEquals("incorrect sign", -1, result.signum());
0606: }
0607:
0608: /**
0609: * flipBit(int n) inside a negative number with all ones in bit representation
0610: */
0611: public void testFlipBitNegativeInside3() {
0612: String as = "-18446744073709551615";
0613: String res = "-18446744073709551611";
0614: int number = 2;
0615: BigInteger aNumber = new BigInteger(as);
0616: BigInteger result = aNumber.flipBit(number);
0617: assertEquals(res, result.toString());
0618: }
0619:
0620: /**
0621: * flipBit(0) in the negative number of length 1
0622: * with all ones in bit representation.
0623: * the resulting number's length is 2.
0624: */
0625: public void testFlipBitNegativeInside4() {
0626: String as = "-4294967295";
0627: String res = "-4294967296";
0628: int number = 0;
0629: BigInteger aNumber = new BigInteger(as);
0630: BigInteger result = aNumber.flipBit(number);
0631: assertEquals(res, result.toString());
0632: }
0633:
0634: /**
0635: * flipBit(0) in the negative number of length 2
0636: * with all ones in bit representation.
0637: * the resulting number's length is 3.
0638: */
0639: public void testFlipBitNegativeInside5() {
0640: String as = "-18446744073709551615";
0641: String res = "-18446744073709551616";
0642: int number = 0;
0643: BigInteger aNumber = new BigInteger(as);
0644: BigInteger result = aNumber.flipBit(number);
0645: assertEquals(res, result.toString());
0646: }
0647:
0648: /**
0649: * flipBit(int n) outside a negative number
0650: */
0651: public void testFlipBitNegativeOutside1() {
0652: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0653: -15, 35, 26 };
0654: int aSign = -1;
0655: int number = 150;
0656: byte rBytes[] = { -65, -1, -1, -1, -1, -1, -2, 127, -57, -101,
0657: 1, 75, -90, -46, -92, -4, 14, -36, -26 };
0658: BigInteger aNumber = new BigInteger(aSign, aBytes);
0659: BigInteger result = aNumber.flipBit(number);
0660: byte resBytes[] = new byte[rBytes.length];
0661: resBytes = result.toByteArray();
0662: for (int i = 0; i < resBytes.length; i++) {
0663: assertTrue(resBytes[i] == rBytes[i]);
0664: }
0665: assertEquals("incorrect sign", -1, result.signum());
0666: }
0667:
0668: /**
0669: * flipBit(int n) outside a negative number
0670: */
0671: public void testFlipBitNegativeOutside2() {
0672: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0673: -15, 35, 26 };
0674: int aSign = -1;
0675: int number = 191;
0676: byte rBytes[] = { -1, 127, -1, -1, -1, -1, -1, -1, -1, -1, -1,
0677: -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14,
0678: -36, -26 };
0679: BigInteger aNumber = new BigInteger(aSign, aBytes);
0680: BigInteger result = aNumber.flipBit(number);
0681: byte resBytes[] = new byte[rBytes.length];
0682: resBytes = result.toByteArray();
0683: for (int i = 0; i < resBytes.length; i++) {
0684: assertTrue(resBytes[i] == rBytes[i]);
0685: }
0686: assertEquals("incorrect sign", -1, result.signum());
0687: }
0688:
0689: /**
0690: * flipBit(int n) inside a positive number
0691: */
0692: public void testFlipBitPositiveInside1() {
0693: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0694: -15, 35, 26 };
0695: int aSign = 1;
0696: int number = 15;
0697: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0698: -15, -93, 26 };
0699: BigInteger aNumber = new BigInteger(aSign, aBytes);
0700: BigInteger result = aNumber.flipBit(number);
0701: byte resBytes[] = new byte[rBytes.length];
0702: resBytes = result.toByteArray();
0703: for (int i = 0; i < resBytes.length; i++) {
0704: assertTrue(resBytes[i] == rBytes[i]);
0705: }
0706: assertEquals("incorrect sign", 1, result.signum());
0707: }
0708:
0709: /**
0710: * flipBit(int n) inside a positive number
0711: */
0712: public void testFlipBitPositiveInside2() {
0713: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0714: -15, 35, 26 };
0715: int aSign = 1;
0716: int number = 45;
0717: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 13, 91, 3,
0718: -15, 35, 26 };
0719: BigInteger aNumber = new BigInteger(aSign, aBytes);
0720: BigInteger result = aNumber.flipBit(number);
0721: byte resBytes[] = new byte[rBytes.length];
0722: resBytes = result.toByteArray();
0723: for (int i = 0; i < resBytes.length; i++) {
0724: assertTrue(resBytes[i] == rBytes[i]);
0725: }
0726: assertEquals("incorrect sign", 1, result.signum());
0727: }
0728:
0729: /**
0730: * flipBit(int n) outside a positive number
0731: */
0732: public void testFlipBitPositiveOutside1() {
0733: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0734: -15, 35, 26 };
0735: int aSign = 1;
0736: int number = 150;
0737: byte rBytes[] = { 64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76,
0738: 89, 45, 91, 3, -15, 35, 26 };
0739: BigInteger aNumber = new BigInteger(aSign, aBytes);
0740: BigInteger result = aNumber.flipBit(number);
0741: byte resBytes[] = new byte[rBytes.length];
0742: resBytes = result.toByteArray();
0743: for (int i = 0; i < resBytes.length; i++) {
0744: assertTrue(resBytes[i] == rBytes[i]);
0745: }
0746: assertEquals("incorrect sign", 1, result.signum());
0747: }
0748:
0749: /**
0750: * flipBit(int n) outside a positive number
0751: */
0752: public void testFlipBitPositiveOutside2() {
0753: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0754: -15, 35, 26 };
0755: int aSign = 1;
0756: int number = 191;
0757: byte rBytes[] = { 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0758: -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26 };
0759: BigInteger aNumber = new BigInteger(aSign, aBytes);
0760: BigInteger result = aNumber.flipBit(number);
0761: byte resBytes[] = new byte[rBytes.length];
0762: resBytes = result.toByteArray();
0763: for (int i = 0; i < resBytes.length; i++) {
0764: assertTrue(resBytes[i] == rBytes[i]);
0765: }
0766: assertEquals("incorrect sign", 1, result.signum());
0767: }
0768:
0769: /**
0770: * setBit(int n) of a negative n
0771: */
0772: public void testSetBitException() {
0773: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0774: -15, 35, 26 };
0775: int aSign = 1;
0776: int number = -7;
0777: BigInteger aNumber = new BigInteger(aSign, aBytes);
0778: try {
0779: aNumber.setBit(number);
0780: fail("ArithmeticException has not been caught");
0781: } catch (ArithmeticException e) {
0782: assertEquals("Improper exception message",
0783: "Negative bit address", e.getMessage());
0784: }
0785: }
0786:
0787: /**
0788: * setBit(int n) outside zero
0789: */
0790: public void testSetBitZero() {
0791: byte aBytes[] = { 0 };
0792: int aSign = 0;
0793: int number = 0;
0794: byte rBytes[] = { 1 };
0795: BigInteger aNumber = new BigInteger(aSign, aBytes);
0796: BigInteger result = aNumber.setBit(number);
0797: byte resBytes[] = new byte[rBytes.length];
0798: resBytes = result.toByteArray();
0799: for (int i = 0; i < resBytes.length; i++) {
0800: assertTrue(resBytes[i] == rBytes[i]);
0801: }
0802: assertEquals("incorrect sign", 1, result.signum());
0803: }
0804:
0805: /**
0806: * setBit(int n) outside zero
0807: */
0808: public void testSetBitZeroOutside1() {
0809: byte aBytes[] = { 0 };
0810: int aSign = 0;
0811: int number = 95;
0812: byte rBytes[] = { 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
0813: BigInteger aNumber = new BigInteger(aSign, aBytes);
0814: BigInteger result = aNumber.setBit(number);
0815: byte resBytes[] = new byte[rBytes.length];
0816: resBytes = result.toByteArray();
0817: for (int i = 0; i < resBytes.length; i++) {
0818: assertTrue(resBytes[i] == rBytes[i]);
0819: }
0820: assertEquals("incorrect sign", 1, result.signum());
0821: }
0822:
0823: /**
0824: * setBit(int n) inside a positive number
0825: */
0826: public void testSetBitPositiveInside1() {
0827: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0828: -15, 35, 26 };
0829: int aSign = 1;
0830: int number = 20;
0831: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0832: -15, 35, 26 };
0833: BigInteger aNumber = new BigInteger(aSign, aBytes);
0834: BigInteger result = aNumber.setBit(number);
0835: byte resBytes[] = new byte[rBytes.length];
0836: resBytes = result.toByteArray();
0837: for (int i = 0; i < resBytes.length; i++) {
0838: assertTrue(resBytes[i] == rBytes[i]);
0839: }
0840: assertEquals("incorrect sign", 1, result.signum());
0841: }
0842:
0843: /**
0844: * setBit(int n) inside a positive number
0845: */
0846: public void testSetBitPositiveInside2() {
0847: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0848: -15, 35, 26 };
0849: int aSign = 1;
0850: int number = 17;
0851: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0852: -13, 35, 26 };
0853: BigInteger aNumber = new BigInteger(aSign, aBytes);
0854: BigInteger result = aNumber.setBit(number);
0855: byte resBytes[] = new byte[rBytes.length];
0856: resBytes = result.toByteArray();
0857: for (int i = 0; i < resBytes.length; i++) {
0858: assertTrue(resBytes[i] == rBytes[i]);
0859: }
0860: assertEquals("incorrect sign", 1, result.signum());
0861: }
0862:
0863: /**
0864: * setBit(int n) inside a positive number
0865: */
0866: public void testSetBitPositiveInside3() {
0867: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0868: -15, 35, 26 };
0869: int aSign = 1;
0870: int number = 45;
0871: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0872: -15, 35, 26 };
0873: BigInteger aNumber = new BigInteger(aSign, aBytes);
0874: BigInteger result = aNumber.setBit(number);
0875: byte resBytes[] = new byte[rBytes.length];
0876: resBytes = result.toByteArray();
0877: for (int i = 0; i < resBytes.length; i++) {
0878: assertTrue(resBytes[i] == rBytes[i]);
0879: }
0880: assertEquals("incorrect sign", 1, result.signum());
0881: }
0882:
0883: /**
0884: * setBit(int n) inside a positive number
0885: */
0886: public void testSetBitPositiveInside4() {
0887: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0888: -15, 35, 26 };
0889: int aSign = 1;
0890: int number = 50;
0891: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 93, 45, 91, 3,
0892: -15, 35, 26 };
0893: BigInteger aNumber = new BigInteger(aSign, aBytes);
0894: BigInteger result = aNumber.setBit(number);
0895: byte resBytes[] = new byte[rBytes.length];
0896: resBytes = result.toByteArray();
0897: for (int i = 0; i < resBytes.length; i++) {
0898: assertTrue(resBytes[i] == rBytes[i]);
0899: }
0900: assertEquals("incorrect sign", 1, result.signum());
0901: }
0902:
0903: /**
0904: * setBit(int n) outside a positive number
0905: */
0906: public void testSetBitPositiveOutside1() {
0907: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0908: -15, 35, 26 };
0909: int aSign = 1;
0910: int number = 150;
0911: byte rBytes[] = { 64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76,
0912: 89, 45, 91, 3, -15, 35, 26 };
0913: BigInteger aNumber = new BigInteger(aSign, aBytes);
0914: BigInteger result = aNumber.setBit(number);
0915: byte resBytes[] = new byte[rBytes.length];
0916: resBytes = result.toByteArray();
0917: for (int i = 0; i < resBytes.length; i++) {
0918: assertTrue(resBytes[i] == rBytes[i]);
0919: }
0920: assertEquals("incorrect sign", 1, result.signum());
0921: }
0922:
0923: /**
0924: * setBit(int n) outside a positive number
0925: */
0926: public void testSetBitPositiveOutside2() {
0927: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0928: -15, 35, 26 };
0929: int aSign = 1;
0930: int number = 223;
0931: byte rBytes[] = { 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0932: 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15,
0933: 35, 26 };
0934: BigInteger aNumber = new BigInteger(aSign, aBytes);
0935: BigInteger result = aNumber.setBit(number);
0936: byte resBytes[] = new byte[rBytes.length];
0937: resBytes = result.toByteArray();
0938: for (int i = 0; i < resBytes.length; i++) {
0939: assertTrue(resBytes[i] == rBytes[i]);
0940: }
0941: assertEquals("incorrect sign", 1, result.signum());
0942: }
0943:
0944: /**
0945: * setBit(int n) the leftmost bit in a positive number
0946: */
0947: public void testSetBitTopPositive() {
0948: byte aBytes[] = { 1, -128, 56, 100, -15, 35, 26 };
0949: int aSign = 1;
0950: int number = 63;
0951: byte rBytes[] = { 0, -128, 1, -128, 56, 100, -15, 35, 26 };
0952: BigInteger aNumber = new BigInteger(aSign, aBytes);
0953: BigInteger result = aNumber.setBit(number);
0954: byte resBytes[] = new byte[rBytes.length];
0955: resBytes = result.toByteArray();
0956: for (int i = 0; i < resBytes.length; i++) {
0957: assertTrue(resBytes[i] == rBytes[i]);
0958: }
0959: assertEquals("incorrect sign", 1, result.signum());
0960: }
0961:
0962: /**
0963: * setBit(int n) the leftmost bit in a negative number
0964: */
0965: public void testSetBitLeftmostNegative() {
0966: byte aBytes[] = { 1, -128, 56, 100, -15, 35, 26 };
0967: int aSign = -1;
0968: int number = 48;
0969: byte rBytes[] = { -1, 127, -57, -101, 14, -36, -26, 49 };
0970: BigInteger aNumber = new BigInteger(aSign, aBytes);
0971: BigInteger result = aNumber.setBit(number);
0972: byte resBytes[] = new byte[rBytes.length];
0973: resBytes = result.toByteArray();
0974: for (int i = 0; i < resBytes.length; i++) {
0975: assertTrue(resBytes[i] == rBytes[i]);
0976: }
0977: assertEquals("incorrect sign", -1, result.signum());
0978: }
0979:
0980: /**
0981: * setBit(int n) inside a negative number
0982: */
0983: public void testSetBitNegativeInside1() {
0984: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
0985: -15, 35, 26 };
0986: int aSign = -1;
0987: int number = 15;
0988: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
0989: 14, -36, -26 };
0990: BigInteger aNumber = new BigInteger(aSign, aBytes);
0991: BigInteger result = aNumber.setBit(number);
0992: byte resBytes[] = new byte[rBytes.length];
0993: resBytes = result.toByteArray();
0994: for (int i = 0; i < resBytes.length; i++) {
0995: assertTrue(resBytes[i] == rBytes[i]);
0996: }
0997: assertEquals("incorrect sign", -1, result.signum());
0998: }
0999:
1000: /**
1001: * setBit(int n) inside a negative number
1002: */
1003: public void testSetBitNegativeInside2() {
1004: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1005: -15, 35, 26 };
1006: int aSign = -1;
1007: int number = 44;
1008: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
1009: 14, -36, -26 };
1010: BigInteger aNumber = new BigInteger(aSign, aBytes);
1011: BigInteger result = aNumber.setBit(number);
1012: byte resBytes[] = new byte[rBytes.length];
1013: resBytes = result.toByteArray();
1014: for (int i = 0; i < resBytes.length; i++) {
1015: assertTrue(resBytes[i] == rBytes[i]);
1016: }
1017: assertEquals("incorrect sign", -1, result.signum());
1018: }
1019:
1020: /**
1021: * setBit(int n) inside a negative number with all ones in bit representation
1022: */
1023: public void testSetBitNegativeInside3() {
1024: String as = "-18446744073709551615";
1025: String res = "-18446744073709551611";
1026: int number = 2;
1027: BigInteger aNumber = new BigInteger(as);
1028: BigInteger result = aNumber.setBit(number);
1029: assertEquals(res, result.toString());
1030: }
1031:
1032: /**
1033: * setBit(0) in the negative number of length 1
1034: * with all ones in bit representation.
1035: * the resulting number's length is 2.
1036: */
1037: public void testSetBitNegativeInside4() {
1038: String as = "-4294967295";
1039: int number = 0;
1040: BigInteger aNumber = new BigInteger(as);
1041: BigInteger result = aNumber.setBit(number);
1042: assertEquals(as, result.toString());
1043: }
1044:
1045: /**
1046: * setBit(0) in the negative number of length 2
1047: * with all ones in bit representation.
1048: * the resulting number's length is 3.
1049: */
1050: public void testSetBitNegativeInside5() {
1051: String as = "-18446744073709551615";
1052: int number = 0;
1053: BigInteger aNumber = new BigInteger(as);
1054: BigInteger result = aNumber.setBit(number);
1055: assertEquals(as, result.toString());
1056: }
1057:
1058: /**
1059: * setBit(int n) outside a negative number
1060: */
1061: public void testSetBitNegativeOutside1() {
1062: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1063: -15, 35, 26 };
1064: int aSign = -1;
1065: int number = 150;
1066: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
1067: 14, -36, -26 };
1068: BigInteger aNumber = new BigInteger(aSign, aBytes);
1069: BigInteger result = aNumber.setBit(number);
1070: byte resBytes[] = new byte[rBytes.length];
1071: resBytes = result.toByteArray();
1072: for (int i = 0; i < resBytes.length; i++) {
1073: assertTrue(resBytes[i] == rBytes[i]);
1074: }
1075: assertEquals("incorrect sign", -1, result.signum());
1076: }
1077:
1078: /**
1079: * setBit(int n) outside a negative number
1080: */
1081: public void testSetBitNegativeOutside2() {
1082: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1083: -15, 35, 26 };
1084: int aSign = -1;
1085: int number = 191;
1086: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
1087: 14, -36, -26 };
1088: BigInteger aNumber = new BigInteger(aSign, aBytes);
1089: BigInteger result = aNumber.setBit(number);
1090: byte resBytes[] = new byte[rBytes.length];
1091: resBytes = result.toByteArray();
1092: for (int i = 0; i < resBytes.length; i++) {
1093: assertTrue(resBytes[i] == rBytes[i]);
1094: }
1095: assertEquals("incorrect sign", -1, result.signum());
1096: }
1097:
1098: /**
1099: * setBit: check the case when the number of bit to be set can be
1100: * represented as n * 32 + 31, where n is an arbitrary integer.
1101: * Here 191 = 5 * 32 + 31
1102: */
1103: public void testSetBitBug1331() {
1104: BigInteger result = BigInteger.valueOf(0L).setBit(191);
1105: assertEquals(
1106: "incorrect value",
1107: "3138550867693340381917894711603833208051177722232017256448",
1108: result.toString());
1109: assertEquals("incorrect sign", 1, result.signum());
1110: }
1111:
1112: /**
1113: * shiftLeft(int n), n = 0
1114: */
1115: public void testShiftLeft1() {
1116: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1117: -15, 35, 26 };
1118: int aSign = 1;
1119: int number = 0;
1120: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1121: -15, 35, 26 };
1122: BigInteger aNumber = new BigInteger(aSign, aBytes);
1123: BigInteger result = aNumber.shiftLeft(number);
1124: byte resBytes[] = new byte[rBytes.length];
1125: resBytes = result.toByteArray();
1126: for (int i = 0; i < resBytes.length; i++) {
1127: assertTrue(resBytes[i] == rBytes[i]);
1128: }
1129: assertEquals("incorrect sign", 1, result.signum());
1130: }
1131:
1132: /**
1133: * shiftLeft(int n), n < 0
1134: */
1135: public void testShiftLeft2() {
1136: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1137: -15, 35, 26 };
1138: int aSign = 1;
1139: int number = -27;
1140: byte rBytes[] = { 48, 7, 12, -97, -42, -117, 37, -85, 96 };
1141: BigInteger aNumber = new BigInteger(aSign, aBytes);
1142: BigInteger result = aNumber.shiftLeft(number);
1143: byte resBytes[] = new byte[rBytes.length];
1144: resBytes = result.toByteArray();
1145: for (int i = 0; i < resBytes.length; i++) {
1146: assertTrue(resBytes[i] == rBytes[i]);
1147: }
1148: assertEquals("incorrect sign", 1, result.signum());
1149: }
1150:
1151: /**
1152: * shiftLeft(int n) a positive number, n > 0
1153: */
1154: public void testShiftLeft3() {
1155: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1156: -15, 35, 26 };
1157: int aSign = 1;
1158: int number = 27;
1159: byte rBytes[] = { 12, 1, -61, 39, -11, -94, -55, 106, -40, 31,
1160: -119, 24, -48, 0, 0, 0 };
1161: BigInteger aNumber = new BigInteger(aSign, aBytes);
1162: BigInteger result = aNumber.shiftLeft(number);
1163: byte resBytes[] = new byte[rBytes.length];
1164: resBytes = result.toByteArray();
1165: for (int i = 0; i < resBytes.length; i++) {
1166: assertTrue(resBytes[i] == rBytes[i]);
1167: }
1168: assertEquals("incorrect sign", 1, result.signum());
1169: }
1170:
1171: /**
1172: * shiftLeft(int n) a positive number, n > 0
1173: */
1174: public void testShiftLeft4() {
1175: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1176: -15, 35, 26 };
1177: int aSign = 1;
1178: int number = 45;
1179: byte rBytes[] = { 48, 7, 12, -97, -42, -117, 37, -85, 96, 126,
1180: 36, 99, 64, 0, 0, 0, 0, 0 };
1181: BigInteger aNumber = new BigInteger(aSign, aBytes);
1182: BigInteger result = aNumber.shiftLeft(number);
1183: byte resBytes[] = new byte[rBytes.length];
1184: resBytes = result.toByteArray();
1185: for (int i = 0; i < resBytes.length; i++) {
1186: assertTrue(resBytes[i] == rBytes[i]);
1187: }
1188: assertEquals("incorrect sign", 1, result.signum());
1189: }
1190:
1191: /**
1192: * shiftLeft(int n) a negative number, n > 0
1193: */
1194: public void testShiftLeft5() {
1195: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1196: -15, 35, 26 };
1197: int aSign = -1;
1198: int number = 45;
1199: byte rBytes[] = { -49, -8, -13, 96, 41, 116, -38, 84, -97,
1200: -127, -37, -100, -64, 0, 0, 0, 0, 0 };
1201: BigInteger aNumber = new BigInteger(aSign, aBytes);
1202: BigInteger result = aNumber.shiftLeft(number);
1203: byte resBytes[] = new byte[rBytes.length];
1204: resBytes = result.toByteArray();
1205: for (int i = 0; i < resBytes.length; i++) {
1206: assertTrue(resBytes[i] == rBytes[i]);
1207: }
1208: assertEquals("incorrect sign", -1, result.signum());
1209: }
1210:
1211: /**
1212: * shiftRight(int n), n = 0
1213: */
1214: public void testShiftRight1() {
1215: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1216: -15, 35, 26 };
1217: int aSign = 1;
1218: int number = 0;
1219: byte rBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1220: -15, 35, 26 };
1221: BigInteger aNumber = new BigInteger(aSign, aBytes);
1222: BigInteger result = aNumber.shiftRight(number);
1223: byte resBytes[] = new byte[rBytes.length];
1224: resBytes = result.toByteArray();
1225: for (int i = 0; i < resBytes.length; i++) {
1226: assertTrue(resBytes[i] == rBytes[i]);
1227: }
1228: assertEquals("incorrect sign", 1, result.signum());
1229: }
1230:
1231: /**
1232: * shiftRight(int n), n < 0
1233: */
1234: public void testShiftRight2() {
1235: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1236: -15, 35, 26 };
1237: int aSign = 1;
1238: int number = -27;
1239: byte rBytes[] = { 12, 1, -61, 39, -11, -94, -55, 106, -40, 31,
1240: -119, 24, -48, 0, 0, 0 };
1241: BigInteger aNumber = new BigInteger(aSign, aBytes);
1242: BigInteger result = aNumber.shiftRight(number);
1243: byte resBytes[] = new byte[rBytes.length];
1244: resBytes = result.toByteArray();
1245: for (int i = 0; i < resBytes.length; i++) {
1246: assertTrue(resBytes[i] == rBytes[i]);
1247: }
1248: assertEquals("incorrect sign", 1, result.signum());
1249: }
1250:
1251: /**
1252: * shiftRight(int n), 0 < n < 32
1253: */
1254: public void testShiftRight3() {
1255: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1256: -15, 35, 26 };
1257: int aSign = 1;
1258: int number = 27;
1259: byte rBytes[] = { 48, 7, 12, -97, -42, -117, 37, -85, 96 };
1260: BigInteger aNumber = new BigInteger(aSign, aBytes);
1261: BigInteger result = aNumber.shiftRight(number);
1262: byte resBytes[] = new byte[rBytes.length];
1263: resBytes = result.toByteArray();
1264: for (int i = 0; i < resBytes.length; i++) {
1265: assertTrue(resBytes[i] == rBytes[i]);
1266: }
1267: assertEquals("incorrect sign", 1, result.signum());
1268: }
1269:
1270: /**
1271: * shiftRight(int n), n > 32
1272: */
1273: public void testShiftRight4() {
1274: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1275: -15, 35, 26 };
1276: int aSign = 1;
1277: int number = 45;
1278: byte rBytes[] = { 12, 1, -61, 39, -11, -94, -55 };
1279: BigInteger aNumber = new BigInteger(aSign, aBytes);
1280: BigInteger result = aNumber.shiftRight(number);
1281: byte resBytes[] = new byte[rBytes.length];
1282: resBytes = result.toByteArray();
1283: for (int i = 0; i < resBytes.length; i++) {
1284: assertTrue(resBytes[i] == rBytes[i]);
1285: }
1286: assertEquals("incorrect sign", 1, result.signum());
1287: }
1288:
1289: /**
1290: * shiftRight(int n), n is greater than bitLength()
1291: */
1292: public void testShiftRight5() {
1293: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1294: -15, 35, 26 };
1295: int aSign = 1;
1296: int number = 300;
1297: byte rBytes[] = { 0 };
1298: BigInteger aNumber = new BigInteger(aSign, aBytes);
1299: BigInteger result = aNumber.shiftRight(number);
1300: byte resBytes[] = new byte[rBytes.length];
1301: resBytes = result.toByteArray();
1302: for (int i = 0; i < resBytes.length; i++) {
1303: assertTrue(resBytes[i] == rBytes[i]);
1304: }
1305: assertEquals("incorrect sign", 0, result.signum());
1306: }
1307:
1308: /**
1309: * shiftRight a negative number;
1310: * shift distance is multiple of 32;
1311: * shifted bits are NOT zeroes.
1312: */
1313: public void testShiftRightNegNonZeroesMul32() {
1314: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 1, 0,
1315: 0, 0, 0, 0, 0, 0 };
1316: int aSign = -1;
1317: int number = 64;
1318: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -92 };
1319: BigInteger aNumber = new BigInteger(aSign, aBytes);
1320: BigInteger result = aNumber.shiftRight(number);
1321: byte resBytes[] = new byte[rBytes.length];
1322: resBytes = result.toByteArray();
1323: for (int i = 0; i < resBytes.length; i++) {
1324: assertTrue(resBytes[i] == rBytes[i]);
1325: }
1326: assertEquals("incorrect sign", -1, result.signum());
1327: }
1328:
1329: /**
1330: * shiftRight a negative number;
1331: * shift distance is NOT multiple of 32;
1332: * shifted bits are NOT zeroes.
1333: */
1334: public void testShiftRightNegNonZeroes() {
1335: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0,
1336: 0, 0, 0, 0, 0, 0 };
1337: int aSign = -1;
1338: int number = 68;
1339: byte rBytes[] = { -25, -4, 121, -80, 20, -70, 109, 42 };
1340: BigInteger aNumber = new BigInteger(aSign, aBytes);
1341: BigInteger result = aNumber.shiftRight(number);
1342: byte resBytes[] = new byte[rBytes.length];
1343: resBytes = result.toByteArray();
1344: for (int i = 0; i < resBytes.length; i++) {
1345: assertTrue(resBytes[i] == rBytes[i]);
1346: }
1347: assertEquals("incorrect sign", -1, result.signum());
1348: }
1349:
1350: /**
1351: * shiftRight a negative number;
1352: * shift distance is NOT multiple of 32;
1353: * shifted bits are zeroes.
1354: */
1355: public void testShiftRightNegZeroes() {
1356: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 0, 0, 0,
1357: 0, 0, 0, 0, 0, 0 };
1358: int aSign = -1;
1359: int number = 68;
1360: byte rBytes[] = { -25, -4, 121, -80, 20, -70, 109, 48 };
1361: BigInteger aNumber = new BigInteger(aSign, aBytes);
1362: BigInteger result = aNumber.shiftRight(number);
1363: byte resBytes[] = new byte[rBytes.length];
1364: resBytes = result.toByteArray();
1365: for (int i = 0; i < resBytes.length; i++) {
1366: assertTrue(resBytes[i] == rBytes[i]);
1367: }
1368: assertEquals("incorrect sign", -1, result.signum());
1369: }
1370:
1371: /**
1372: * shiftRight a negative number;
1373: * shift distance is multiple of 32;
1374: * shifted bits are zeroes.
1375: */
1376: public void testShiftRightNegZeroesMul32() {
1377: byte aBytes[] = { 1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0,
1378: 0, 0, 0, 0, 0, 0 };
1379: int aSign = -1;
1380: int number = 64;
1381: byte rBytes[] = { -2, 127, -57, -101, 1, 75, -90, -46, -91 };
1382: BigInteger aNumber = new BigInteger(aSign, aBytes);
1383: BigInteger result = aNumber.shiftRight(number);
1384: byte resBytes[] = new byte[rBytes.length];
1385: resBytes = result.toByteArray();
1386: for (int i = 0; i < resBytes.length; i++) {
1387: assertTrue(resBytes[i] == rBytes[i]);
1388: }
1389: assertEquals("incorrect sign", -1, result.signum());
1390: }
1391:
1392: /**
1393: * testBit(int n) of a negative n
1394: */
1395: public void testTestBitException() {
1396: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1397: -15, 35, 26 };
1398: int aSign = 1;
1399: int number = -7;
1400: BigInteger aNumber = new BigInteger(aSign, aBytes);
1401: try {
1402: aNumber.testBit(number);
1403: fail("ArithmeticException has not been caught");
1404: } catch (ArithmeticException e) {
1405: assertEquals("Improper exception message",
1406: "Negative bit address", e.getMessage());
1407: }
1408: }
1409:
1410: /**
1411: * testBit(int n) of a positive number
1412: */
1413: public void testTestBitPositive1() {
1414: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1415: -15, 35, 26 };
1416: int aSign = 1;
1417: int number = 7;
1418: BigInteger aNumber = new BigInteger(aSign, aBytes);
1419: assertTrue(!aNumber.testBit(number));
1420: }
1421:
1422: /**
1423: * testBit(int n) of a positive number
1424: */
1425: public void testTestBitPositive2() {
1426: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1427: -15, 35, 26 };
1428: int aSign = 1;
1429: int number = 45;
1430: BigInteger aNumber = new BigInteger(aSign, aBytes);
1431: assertTrue(aNumber.testBit(number));
1432: }
1433:
1434: /**
1435: * testBit(int n) of a positive number, n > bitLength()
1436: */
1437: public void testTestBitPositive3() {
1438: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1439: -15, 35, 26 };
1440: int aSign = 1;
1441: int number = 300;
1442: BigInteger aNumber = new BigInteger(aSign, aBytes);
1443: assertTrue(!aNumber.testBit(number));
1444: }
1445:
1446: /**
1447: * testBit(int n) of a negative number
1448: */
1449: public void testTestBitNegative1() {
1450: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1451: -15, 35, 26 };
1452: int aSign = -1;
1453: int number = 7;
1454: BigInteger aNumber = new BigInteger(aSign, aBytes);
1455: assertTrue(aNumber.testBit(number));
1456: }
1457:
1458: /**
1459: * testBit(int n) of a positive n
1460: */
1461: public void testTestBitNegative2() {
1462: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1463: -15, 35, 26 };
1464: int aSign = -1;
1465: int number = 45;
1466: BigInteger aNumber = new BigInteger(aSign, aBytes);
1467: assertTrue(!aNumber.testBit(number));
1468: }
1469:
1470: /**
1471: * testBit(int n) of a positive n, n > bitLength()
1472: */
1473: public void testTestBitNegative3() {
1474: byte aBytes[] = { -1, -128, 56, 100, -2, -76, 89, 45, 91, 3,
1475: -15, 35, 26 };
1476: int aSign = -1;
1477: int number = 300;
1478: BigInteger aNumber = new BigInteger(aSign, aBytes);
1479: assertTrue(aNumber.testBit(number));
1480: }
1481: }
|