| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.harmony.tests.java.math; |
| |
| import java.math.BigInteger; |
| import java.util.Random; |
| |
| public class BigIntegerTest extends junit.framework.TestCase { |
| |
| BigInteger minusTwo = new BigInteger("-2", 10); |
| |
| BigInteger minusOne = new BigInteger("-1", 10); |
| |
| BigInteger zero = new BigInteger("0", 10); |
| |
| BigInteger one = new BigInteger("1", 10); |
| |
| BigInteger two = new BigInteger("2", 10); |
| |
| BigInteger ten = new BigInteger("10", 10); |
| |
| BigInteger sixteen = new BigInteger("16", 10); |
| |
| BigInteger oneThousand = new BigInteger("1000", 10); |
| |
| BigInteger aZillion = new BigInteger( |
| "100000000000000000000000000000000000000000000000000", 10); |
| |
| BigInteger twoToTheTen = new BigInteger("1024", 10); |
| |
| BigInteger twoToTheSeventy = two.pow(70); |
| |
| Random rand = new Random(); |
| |
| BigInteger bi; |
| |
| BigInteger bi1; |
| |
| BigInteger bi2; |
| |
| BigInteger bi3; |
| |
| BigInteger bi11; |
| |
| BigInteger bi22; |
| |
| BigInteger bi33; |
| |
| BigInteger bi12; |
| |
| BigInteger bi23; |
| |
| BigInteger bi13; |
| |
| BigInteger largePos; |
| |
| BigInteger smallPos; |
| |
| BigInteger largeNeg; |
| |
| BigInteger smallNeg; |
| |
| BigInteger[][] booleanPairs; |
| |
| /** |
| * @tests java.math.BigInteger#BigInteger(int, java.util.Random) |
| */ |
| public void test_ConstructorILjava_util_Random() { |
| // regression test for HARMONY-1047 removed. We were failing this supposed test for RI |
| // behavior in spite of running their code. |
| |
| bi = new BigInteger(70, rand); |
| bi2 = new BigInteger(70, rand); |
| assertTrue("Random number is negative", bi.compareTo(zero) >= 0); |
| assertTrue("Random number is too big", |
| bi.compareTo(twoToTheSeventy) < 0); |
| assertTrue( |
| "Two random numbers in a row are the same (might not be a bug but it very likely is)", |
| !bi.equals(bi2)); |
| assertTrue("Not zero", new BigInteger(0, rand).equals(BigInteger.ZERO)); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#BigInteger(byte[]) |
| */ |
| public void test_Constructor$B() { |
| byte[] myByteArray; |
| myByteArray = new byte[] { (byte) 0x00, (byte) 0xFF, (byte) 0xFE }; |
| bi = new BigInteger(myByteArray); |
| assertTrue("Incorrect value for pos number", bi.equals(BigInteger.ZERO |
| .setBit(16).subtract(two))); |
| myByteArray = new byte[] { (byte) 0xFF, (byte) 0xFE }; |
| bi = new BigInteger(myByteArray); |
| assertTrue("Incorrect value for neg number", bi.equals(minusTwo)); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#BigInteger(int, byte[]) |
| */ |
| public void test_ConstructorI$B() { |
| byte[] myByteArray; |
| myByteArray = new byte[] { (byte) 0xFF, (byte) 0xFE }; |
| bi = new BigInteger(1, myByteArray); |
| assertTrue("Incorrect value for pos number", bi.equals(BigInteger.ZERO |
| .setBit(16).subtract(two))); |
| bi = new BigInteger(-1, myByteArray); |
| assertTrue("Incorrect value for neg number", bi.equals(BigInteger.ZERO |
| .setBit(16).subtract(two).negate())); |
| myByteArray = new byte[] { (byte) 0, (byte) 0 }; |
| bi = new BigInteger(0, myByteArray); |
| assertTrue("Incorrect value for zero", bi.equals(zero)); |
| myByteArray = new byte[] { (byte) 1 }; |
| try { |
| new BigInteger(0, myByteArray); |
| fail("Failed to throw NumberFormatException"); |
| } catch (NumberFormatException e) { |
| // correct |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#BigInteger(java.lang.String) |
| */ |
| public void test_constructor_String_empty() { |
| try { |
| new BigInteger(""); |
| fail("Expected NumberFormatException for new BigInteger(\"\")"); |
| } catch (NumberFormatException e) { |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#toByteArray() |
| */ |
| public void test_toByteArray() { |
| byte[] myByteArray, anotherByteArray; |
| myByteArray = new byte[] { 97, 33, 120, 124, 50, 2, 0, 0, 0, 12, 124, |
| 42 }; |
| anotherByteArray = new BigInteger(myByteArray).toByteArray(); |
| assertTrue("Incorrect byte array returned", |
| myByteArray.length == anotherByteArray.length); |
| for (int counter = myByteArray.length - 1; counter >= 0; counter--) { |
| assertTrue("Incorrect values in returned byte array", |
| myByteArray[counter] == anotherByteArray[counter]); |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#isProbablePrime(int) |
| */ |
| public void test_isProbablePrimeI() { |
| int fails = 0; |
| bi = new BigInteger(20, 20, rand); |
| if (!bi.isProbablePrime(17)) { |
| fails++; |
| } |
| bi = new BigInteger("4", 10); |
| if (bi.isProbablePrime(17)) { |
| fail("isProbablePrime failed for: " + bi); |
| } |
| bi = BigInteger.valueOf(17L * 13L); |
| if (bi.isProbablePrime(17)) { |
| fail("isProbablePrime failed for: " + bi); |
| } |
| for (long a = 2; a < 1000; a++) { |
| if (isPrime(a)) { |
| assertTrue("false negative on prime number <1000", BigInteger |
| .valueOf(a).isProbablePrime(5)); |
| } else if (BigInteger.valueOf(a).isProbablePrime(17)) { |
| System.out.println("isProbablePrime failed for: " + a); |
| fails++; |
| } |
| } |
| for (int a = 0; a < 1000; a++) { |
| bi = BigInteger.valueOf(rand.nextInt(1000000)).multiply( |
| BigInteger.valueOf(rand.nextInt(1000000))); |
| if (bi.isProbablePrime(17)) { |
| System.out.println("isProbablePrime failed for: " + bi); |
| fails++; |
| } |
| } |
| for (int a = 0; a < 200; a++) { |
| bi = new BigInteger(70, rand).multiply(new BigInteger(70, rand)); |
| if (bi.isProbablePrime(17)) { |
| System.out.println("isProbablePrime failed for: " + bi); |
| fails++; |
| } |
| } |
| assertTrue("Too many false positives - may indicate a problem", |
| fails <= 1); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#equals(java.lang.Object) |
| */ |
| public void test_equalsLjava_lang_Object() { |
| assertTrue("0=0", zero.equals(BigInteger.valueOf(0))); |
| assertTrue("-123=-123", BigInteger.valueOf(-123).equals( |
| BigInteger.valueOf(-123))); |
| assertTrue("0=1", !zero.equals(one)); |
| assertTrue("0=-1", !zero.equals(minusOne)); |
| assertTrue("1=-1", !one.equals(minusOne)); |
| assertTrue("bi3=bi3", bi3.equals(bi3)); |
| assertTrue("bi3=copy of bi3", bi3.equals(bi3.negate().negate())); |
| assertTrue("bi3=bi2", !bi3.equals(bi2)); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#compareTo(java.math.BigInteger) |
| */ |
| public void test_compareToLjava_math_BigInteger() { |
| assertTrue("Smaller number returned >= 0", one.compareTo(two) < 0); |
| assertTrue("Larger number returned >= 0", two.compareTo(one) > 0); |
| assertTrue("Equal numbers did not return 0", one.compareTo(one) == 0); |
| assertTrue("Neg number messed things up", |
| two.negate().compareTo(one) < 0); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#intValue() |
| */ |
| public void test_intValue() { |
| assertTrue("Incorrect intValue for 2**70", |
| twoToTheSeventy.intValue() == 0); |
| assertTrue("Incorrect intValue for 2", two.intValue() == 2); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#longValue() |
| */ |
| public void test_longValue() { |
| assertTrue("Incorrect longValue for 2**70", |
| twoToTheSeventy.longValue() == 0); |
| assertTrue("Incorrect longValue for 2", two.longValue() == 2); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#valueOf(long) |
| */ |
| public void test_valueOfJ() { |
| assertTrue("Incurred number returned for 2", BigInteger.valueOf(2L) |
| .equals(two)); |
| assertTrue("Incurred number returned for 200", BigInteger.valueOf(200L) |
| .equals(BigInteger.valueOf(139).add(BigInteger.valueOf(61)))); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#add(java.math.BigInteger) |
| */ |
| public void test_addLjava_math_BigInteger() { |
| assertTrue("Incorrect sum--wanted a zillion", aZillion.add(aZillion) |
| .add(aZillion.negate()).equals(aZillion)); |
| assertTrue("0+0", zero.add(zero).equals(zero)); |
| assertTrue("0+1", zero.add(one).equals(one)); |
| assertTrue("1+0", one.add(zero).equals(one)); |
| assertTrue("1+1", one.add(one).equals(two)); |
| assertTrue("0+(-1)", zero.add(minusOne).equals(minusOne)); |
| assertTrue("(-1)+0", minusOne.add(zero).equals(minusOne)); |
| assertTrue("(-1)+(-1)", minusOne.add(minusOne).equals(minusTwo)); |
| assertTrue("1+(-1)", one.add(minusOne).equals(zero)); |
| assertTrue("(-1)+1", minusOne.add(one).equals(zero)); |
| |
| for (int i = 0; i < 200; i++) { |
| BigInteger midbit = zero.setBit(i); |
| assertTrue("add fails to carry on bit " + i, midbit.add(midbit) |
| .equals(zero.setBit(i + 1))); |
| } |
| BigInteger bi2p3 = bi2.add(bi3); |
| BigInteger bi3p2 = bi3.add(bi2); |
| assertTrue("bi2p3=bi3p2", bi2p3.equals(bi3p2)); |
| |
| // add large positive + small positive |
| |
| // add large positive + small negative |
| |
| // add large negative + small positive |
| |
| // add large negative + small negative |
| } |
| |
| /** |
| * @tests java.math.BigInteger#negate() |
| */ |
| @SuppressWarnings("ConstantOverflow") |
| public void test_negate() { |
| assertTrue("Single negation of zero did not result in zero", zero |
| .negate().equals(zero)); |
| assertTrue("Single negation resulted in original nonzero number", |
| !aZillion.negate().equals(aZillion)); |
| assertTrue("Double negation did not result in original number", |
| aZillion.negate().negate().equals(aZillion)); |
| |
| assertTrue("0.neg", zero.negate().equals(zero)); |
| assertTrue("1.neg", one.negate().equals(minusOne)); |
| assertTrue("2.neg", two.negate().equals(minusTwo)); |
| assertTrue("-1.neg", minusOne.negate().equals(one)); |
| assertTrue("-2.neg", minusTwo.negate().equals(two)); |
| assertTrue("0x62EB40FEF85AA9EBL*2.neg", BigInteger.valueOf( |
| 0x62EB40FEF85AA9EBL * 2).negate().equals( |
| BigInteger.valueOf(-0x62EB40FEF85AA9EBL * 2))); |
| for (int i = 0; i < 200; i++) { |
| BigInteger midbit = zero.setBit(i); |
| BigInteger negate = midbit.negate(); |
| assertTrue("negate negate", negate.negate().equals(midbit)); |
| assertTrue("neg fails on bit " + i, midbit.negate().add(midbit) |
| .equals(zero)); |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#signum() |
| */ |
| public void test_signum() { |
| assertTrue("Wrong positive signum", two.signum() == 1); |
| assertTrue("Wrong zero signum", zero.signum() == 0); |
| assertTrue("Wrong neg zero signum", zero.negate().signum() == 0); |
| assertTrue("Wrong neg signum", two.negate().signum() == -1); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#abs() |
| */ |
| public void test_abs() { |
| assertTrue("Invalid number returned for zillion", aZillion.negate() |
| .abs().equals(aZillion.abs())); |
| assertTrue("Invalid number returned for zero neg", zero.negate().abs() |
| .equals(zero)); |
| assertTrue("Invalid number returned for zero", zero.abs().equals(zero)); |
| assertTrue("Invalid number returned for two", two.negate().abs() |
| .equals(two)); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#pow(int) |
| */ |
| public void test_powI() { |
| assertTrue("Incorrect exponent returned for 2**10", two.pow(10).equals( |
| twoToTheTen)); |
| assertTrue("Incorrect exponent returned for 2**70", two.pow(30) |
| .multiply(two.pow(40)).equals(twoToTheSeventy)); |
| assertTrue("Incorrect exponent returned for 10**50", ten.pow(50) |
| .equals(aZillion)); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#modInverse(java.math.BigInteger) |
| */ |
| public void test_modInverseLjava_math_BigInteger() { |
| BigInteger a = zero, mod, inv; |
| for (int j = 3; j < 50; j++) { |
| mod = BigInteger.valueOf(j); |
| for (int i = -j + 1; i < j; i++) { |
| try { |
| a = BigInteger.valueOf(i); |
| inv = a.modInverse(mod); |
| assertTrue("bad inverse: " + a + " inv mod " + mod |
| + " equals " + inv, one.equals(a.multiply(inv).mod( |
| mod))); |
| assertTrue("inverse greater than modulo: " + a |
| + " inv mod " + mod + " equals " + inv, inv |
| .compareTo(mod) < 0); |
| assertTrue("inverse less than zero: " + a + " inv mod " |
| + mod + " equals " + inv, inv |
| .compareTo(BigInteger.ZERO) >= 0); |
| } catch (ArithmeticException e) { |
| assertTrue("should have found inverse for " + a + " mod " |
| + mod, !one.equals(a.gcd(mod))); |
| } |
| } |
| } |
| for (int j = 1; j < 10; j++) { |
| mod = bi2.add(BigInteger.valueOf(j)); |
| for (int i = 0; i < 20; i++) { |
| try { |
| a = bi3.add(BigInteger.valueOf(i)); |
| inv = a.modInverse(mod); |
| assertTrue("bad inverse: " + a + " inv mod " + mod |
| + " equals " + inv, one.equals(a.multiply(inv).mod( |
| mod))); |
| assertTrue("inverse greater than modulo: " + a |
| + " inv mod " + mod + " equals " + inv, inv |
| .compareTo(mod) < 0); |
| assertTrue("inverse less than zero: " + a + " inv mod " |
| + mod + " equals " + inv, inv |
| .compareTo(BigInteger.ZERO) >= 0); |
| } catch (ArithmeticException e) { |
| assertTrue("should have found inverse for " + a + " mod " |
| + mod, !one.equals(a.gcd(mod))); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#shiftRight(int) |
| */ |
| public void test_shiftRightI() { |
| assertTrue("1 >> 0", BigInteger.valueOf(1).shiftRight(0).equals( |
| BigInteger.ONE)); |
| assertTrue("1 >> 1", BigInteger.valueOf(1).shiftRight(1).equals( |
| BigInteger.ZERO)); |
| assertTrue("1 >> 63", BigInteger.valueOf(1).shiftRight(63).equals( |
| BigInteger.ZERO)); |
| assertTrue("1 >> 64", BigInteger.valueOf(1).shiftRight(64).equals( |
| BigInteger.ZERO)); |
| assertTrue("1 >> 65", BigInteger.valueOf(1).shiftRight(65).equals( |
| BigInteger.ZERO)); |
| assertTrue("1 >> 1000", BigInteger.valueOf(1).shiftRight(1000).equals( |
| BigInteger.ZERO)); |
| assertTrue("-1 >> 0", BigInteger.valueOf(-1).shiftRight(0).equals( |
| minusOne)); |
| assertTrue("-1 >> 1", BigInteger.valueOf(-1).shiftRight(1).equals( |
| minusOne)); |
| assertTrue("-1 >> 63", BigInteger.valueOf(-1).shiftRight(63).equals( |
| minusOne)); |
| assertTrue("-1 >> 64", BigInteger.valueOf(-1).shiftRight(64).equals( |
| minusOne)); |
| assertTrue("-1 >> 65", BigInteger.valueOf(-1).shiftRight(65).equals( |
| minusOne)); |
| assertTrue("-1 >> 1000", BigInteger.valueOf(-1).shiftRight(1000) |
| .equals(minusOne)); |
| |
| BigInteger a = BigInteger.ONE; |
| BigInteger c = bi3; |
| BigInteger E = bi3.negate(); |
| BigInteger e = E; |
| for (int i = 0; i < 200; i++) { |
| BigInteger b = BigInteger.ZERO.setBit(i); |
| assertTrue("a==b", a.equals(b)); |
| a = a.shiftLeft(1); |
| assertTrue("a non-neg", a.signum() >= 0); |
| |
| BigInteger d = bi3.shiftRight(i); |
| assertTrue("c==d", c.equals(d)); |
| c = c.shiftRight(1); |
| assertTrue(">>1 == /2", d.divide(two).equals(c)); |
| assertTrue("c non-neg", c.signum() >= 0); |
| |
| BigInteger f = E.shiftRight(i); |
| assertTrue("e==f", e.equals(f)); |
| e = e.shiftRight(1); |
| assertTrue(">>1 == /2", f.subtract(one).divide(two).equals(e)); |
| assertTrue("e negative", e.signum() == -1); |
| |
| assertTrue("b >> i", b.shiftRight(i).equals(one)); |
| assertTrue("b >> i+1", b.shiftRight(i + 1).equals(zero)); |
| assertTrue("b >> i-1", b.shiftRight(i - 1).equals(two)); |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#shiftLeft(int) |
| */ |
| public void test_shiftLeftI() { |
| assertTrue("1 << 0", one.shiftLeft(0).equals(one)); |
| assertTrue("1 << 1", one.shiftLeft(1).equals(two)); |
| assertTrue("1 << 63", one.shiftLeft(63).equals( |
| new BigInteger("8000000000000000", 16))); |
| assertTrue("1 << 64", one.shiftLeft(64).equals( |
| new BigInteger("10000000000000000", 16))); |
| assertTrue("1 << 65", one.shiftLeft(65).equals( |
| new BigInteger("20000000000000000", 16))); |
| assertTrue("-1 << 0", minusOne.shiftLeft(0).equals(minusOne)); |
| assertTrue("-1 << 1", minusOne.shiftLeft(1).equals(minusTwo)); |
| assertTrue("-1 << 63", minusOne.shiftLeft(63).equals( |
| new BigInteger("-9223372036854775808"))); |
| assertTrue("-1 << 64", minusOne.shiftLeft(64).equals( |
| new BigInteger("-18446744073709551616"))); |
| assertTrue("-1 << 65", minusOne.shiftLeft(65).equals( |
| new BigInteger("-36893488147419103232"))); |
| |
| BigInteger a = bi3; |
| BigInteger c = minusOne; |
| for (int i = 0; i < 200; i++) { |
| BigInteger b = bi3.shiftLeft(i); |
| assertTrue("a==b", a.equals(b)); |
| assertTrue("a >> i == bi3", a.shiftRight(i).equals(bi3)); |
| a = a.shiftLeft(1); |
| assertTrue("<<1 == *2", b.multiply(two).equals(a)); |
| assertTrue("a non-neg", a.signum() >= 0); |
| assertTrue("a.bitCount==b.bitCount", a.bitCount() == b.bitCount()); |
| |
| BigInteger d = minusOne.shiftLeft(i); |
| assertTrue("c==d", c.equals(d)); |
| c = c.shiftLeft(1); |
| assertTrue("<<1 == *2 negative", d.multiply(two).equals(c)); |
| assertTrue("c negative", c.signum() == -1); |
| assertTrue("d >> i == minusOne", d.shiftRight(i).equals(minusOne)); |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#multiply(java.math.BigInteger) |
| */ |
| public void test_multiplyLjava_math_BigInteger() { |
| assertTrue("Incorrect sum--wanted three zillion", aZillion |
| .add(aZillion).add(aZillion).equals( |
| aZillion.multiply(new BigInteger("3", 10)))); |
| |
| assertTrue("0*0", zero.multiply(zero).equals(zero)); |
| assertTrue("0*1", zero.multiply(one).equals(zero)); |
| assertTrue("1*0", one.multiply(zero).equals(zero)); |
| assertTrue("1*1", one.multiply(one).equals(one)); |
| assertTrue("0*(-1)", zero.multiply(minusOne).equals(zero)); |
| assertTrue("(-1)*0", minusOne.multiply(zero).equals(zero)); |
| assertTrue("(-1)*(-1)", minusOne.multiply(minusOne).equals(one)); |
| assertTrue("1*(-1)", one.multiply(minusOne).equals(minusOne)); |
| assertTrue("(-1)*1", minusOne.multiply(one).equals(minusOne)); |
| |
| testAllMults(bi1, bi1, bi11); |
| testAllMults(bi2, bi2, bi22); |
| testAllMults(bi3, bi3, bi33); |
| testAllMults(bi1, bi2, bi12); |
| testAllMults(bi1, bi3, bi13); |
| testAllMults(bi2, bi3, bi23); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#divide(java.math.BigInteger) |
| */ |
| public void test_divideLjava_math_BigInteger() { |
| testAllDivs(bi33, bi3); |
| testAllDivs(bi22, bi2); |
| testAllDivs(bi11, bi1); |
| testAllDivs(bi13, bi1); |
| testAllDivs(bi13, bi3); |
| testAllDivs(bi12, bi1); |
| testAllDivs(bi12, bi2); |
| testAllDivs(bi23, bi2); |
| testAllDivs(bi23, bi3); |
| testAllDivs(largePos, bi1); |
| testAllDivs(largePos, bi2); |
| testAllDivs(largePos, bi3); |
| testAllDivs(largeNeg, bi1); |
| testAllDivs(largeNeg, bi2); |
| testAllDivs(largeNeg, bi3); |
| testAllDivs(largeNeg, largePos); |
| testAllDivs(largePos, largeNeg); |
| testAllDivs(bi3, bi3); |
| testAllDivs(bi2, bi2); |
| testAllDivs(bi1, bi1); |
| testDivRanges(bi1); |
| testDivRanges(bi2); |
| testDivRanges(bi3); |
| testDivRanges(smallPos); |
| testDivRanges(largePos); |
| testDivRanges(new BigInteger("62EB40FEF85AA9EB", 16)); |
| testAllDivs(BigInteger.valueOf(0xCC0225953CL), BigInteger |
| .valueOf(0x1B937B765L)); |
| |
| try { |
| largePos.divide(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi1.divide(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi3.negate().divide(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| zero.divide(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#remainder(java.math.BigInteger) |
| */ |
| public void test_remainderLjava_math_BigInteger() { |
| try { |
| largePos.remainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi1.remainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi3.negate().remainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| zero.remainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#mod(java.math.BigInteger) |
| */ |
| public void test_modLjava_math_BigInteger() { |
| try { |
| largePos.mod(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi1.mod(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi3.negate().mod(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| zero.mod(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#divideAndRemainder(java.math.BigInteger) |
| */ |
| public void test_divideAndRemainderLjava_math_BigInteger() { |
| try { |
| largePos.divideAndRemainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi1.divideAndRemainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| bi3.negate().divideAndRemainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| |
| try { |
| zero.divideAndRemainder(zero); |
| fail("ArithmeticException expected"); |
| } catch (ArithmeticException e) { |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#BigInteger(java.lang.String) |
| */ |
| public void test_ConstructorLjava_lang_String() { |
| assertTrue("new(0)", new BigInteger("0").equals(BigInteger.valueOf(0))); |
| assertTrue("new(1)", new BigInteger("1").equals(BigInteger.valueOf(1))); |
| assertTrue("new(12345678901234)", new BigInteger("12345678901234") |
| .equals(BigInteger.valueOf(12345678901234L))); |
| assertTrue("new(-1)", new BigInteger("-1").equals(BigInteger |
| .valueOf(-1))); |
| assertTrue("new(-12345678901234)", new BigInteger("-12345678901234") |
| .equals(BigInteger.valueOf(-12345678901234L))); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#BigInteger(java.lang.String, int) |
| */ |
| public void test_ConstructorLjava_lang_StringI() { |
| assertTrue("new(0,16)", new BigInteger("0", 16).equals(BigInteger |
| .valueOf(0))); |
| assertTrue("new(1,16)", new BigInteger("1", 16).equals(BigInteger |
| .valueOf(1))); |
| assertTrue("new(ABF345678901234,16)", new BigInteger("ABF345678901234", |
| 16).equals(BigInteger.valueOf(0xABF345678901234L))); |
| assertTrue("new(abf345678901234,16)", new BigInteger("abf345678901234", |
| 16).equals(BigInteger.valueOf(0xABF345678901234L))); |
| assertTrue("new(-1,16)", new BigInteger("-1", 16).equals(BigInteger |
| .valueOf(-1))); |
| assertTrue("new(-ABF345678901234,16)", new BigInteger( |
| "-ABF345678901234", 16).equals(BigInteger |
| .valueOf(-0xABF345678901234L))); |
| assertTrue("new(-abf345678901234,16)", new BigInteger( |
| "-abf345678901234", 16).equals(BigInteger |
| .valueOf(-0xABF345678901234L))); |
| assertTrue("new(-101010101,2)", new BigInteger("-101010101", 2) |
| .equals(BigInteger.valueOf(-341))); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#toString() |
| */ |
| public void test_toString() { |
| assertTrue("0.toString", "0".equals(BigInteger.valueOf(0).toString())); |
| assertTrue("1.toString", "1".equals(BigInteger.valueOf(1).toString())); |
| assertTrue("12345678901234.toString", "12345678901234" |
| .equals(BigInteger.valueOf(12345678901234L).toString())); |
| assertTrue("-1.toString", "-1" |
| .equals(BigInteger.valueOf(-1).toString())); |
| assertTrue("-12345678901234.toString", "-12345678901234" |
| .equals(BigInteger.valueOf(-12345678901234L).toString())); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#toString(int) |
| */ |
| public void test_toStringI() { |
| assertTrue("0.toString(16)", "0".equals(BigInteger.valueOf(0).toString( |
| 16))); |
| assertTrue("1.toString(16)", "1".equals(BigInteger.valueOf(1).toString( |
| 16))); |
| assertTrue("ABF345678901234.toString(16)", "abf345678901234" |
| .equals(BigInteger.valueOf(0xABF345678901234L).toString(16))); |
| assertTrue("-1.toString(16)", "-1".equals(BigInteger.valueOf(-1) |
| .toString(16))); |
| assertTrue("-ABF345678901234.toString(16)", "-abf345678901234" |
| .equals(BigInteger.valueOf(-0xABF345678901234L).toString(16))); |
| assertTrue("-101010101.toString(2)", "-101010101".equals(BigInteger |
| .valueOf(-341).toString(2))); |
| } |
| |
| /** |
| * @tests java.math.BigInteger#and(java.math.BigInteger) |
| */ |
| public void test_andLjava_math_BigInteger() { |
| for (BigInteger[] element : booleanPairs) { |
| BigInteger i1 = element[0], i2 = element[1]; |
| BigInteger res = i1.and(i2); |
| assertTrue("symmetry of and", res.equals(i2.and(i1))); |
| int len = Math.max(i1.bitLength(), i2.bitLength()) + 66; |
| for (int i = 0; i < len; i++) { |
| assertTrue("and", (i1.testBit(i) && i2.testBit(i)) == res |
| .testBit(i)); |
| } |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#or(java.math.BigInteger) |
| */ |
| public void test_orLjava_math_BigInteger() { |
| for (BigInteger[] element : booleanPairs) { |
| BigInteger i1 = element[0], i2 = element[1]; |
| BigInteger res = i1.or(i2); |
| assertTrue("symmetry of or", res.equals(i2.or(i1))); |
| int len = Math.max(i1.bitLength(), i2.bitLength()) + 66; |
| for (int i = 0; i < len; i++) { |
| assertTrue("or", (i1.testBit(i) || i2.testBit(i)) == res |
| .testBit(i)); |
| } |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#xor(java.math.BigInteger) |
| */ |
| public void test_xorLjava_math_BigInteger() { |
| for (BigInteger[] element : booleanPairs) { |
| BigInteger i1 = element[0], i2 = element[1]; |
| BigInteger res = i1.xor(i2); |
| assertTrue("symmetry of xor", res.equals(i2.xor(i1))); |
| int len = Math.max(i1.bitLength(), i2.bitLength()) + 66; |
| for (int i = 0; i < len; i++) { |
| assertTrue("xor", (i1.testBit(i) ^ i2.testBit(i)) == res |
| .testBit(i)); |
| } |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#not() |
| */ |
| public void test_not() { |
| for (BigInteger[] element : booleanPairs) { |
| BigInteger i1 = element[0]; |
| BigInteger res = i1.not(); |
| int len = i1.bitLength() + 66; |
| for (int i = 0; i < len; i++) { |
| assertTrue("not", !i1.testBit(i) == res.testBit(i)); |
| } |
| } |
| } |
| |
| /** |
| * @tests java.math.BigInteger#andNot(java.math.BigInteger) |
| */ |
| public void test_andNotLjava_math_BigInteger() { |
| for (BigInteger[] element : booleanPairs) { |
| BigInteger i1 = element[0], i2 = element[1]; |
| BigInteger res = i1.andNot(i2); |
| int len = Math.max(i1.bitLength(), i2.bitLength()) + 66; |
| for (int i = 0; i < len; i++) { |
| assertTrue("andNot", (i1.testBit(i) && !i2.testBit(i)) == res |
| .testBit(i)); |
| } |
| // asymmetrical |
| i1 = element[1]; |
| i2 = element[0]; |
| res = i1.andNot(i2); |
| for (int i = 0; i < len; i++) { |
| assertTrue("andNot reversed", |
| (i1.testBit(i) && !i2.testBit(i)) == res.testBit(i)); |
| } |
| } |
| //regression for HARMONY-4653 |
| try{ |
| BigInteger.ZERO.andNot(null); |
| fail("should throw NPE"); |
| }catch(Exception e){ |
| //expected |
| } |
| BigInteger bi = new BigInteger(0, new byte[]{}); |
| assertEquals(BigInteger.ZERO, bi.andNot(BigInteger.ZERO)); |
| } |
| |
| |
| public void testClone() { |
| // Regression test for HARMONY-1770 |
| MyBigInteger myBigInteger = new MyBigInteger("12345"); |
| myBigInteger = (MyBigInteger) myBigInteger.clone(); |
| } |
| |
| static class MyBigInteger extends BigInteger implements Cloneable { |
| public MyBigInteger(String val) { |
| super(val); |
| } |
| public Object clone() { |
| try { |
| return super.clone(); |
| } catch (CloneNotSupportedException e) { |
| return null; |
| } |
| } |
| } |
| |
| @Override |
| protected void setUp() { |
| bi1 = new BigInteger("2436798324768978", 16); |
| bi2 = new BigInteger("4576829475724387584378543764555", 16); |
| bi3 = new BigInteger("43987298363278574365732645872643587624387563245", |
| 16); |
| |
| bi33 = new BigInteger( |
| "10730846694701319120609898625733976090865327544790136667944805934175543888691400559249041094474885347922769807001", |
| 10); |
| bi22 = new BigInteger( |
| "33301606932171509517158059487795669025817912852219962782230629632224456249", |
| 10); |
| bi11 = new BigInteger("6809003003832961306048761258711296064", 10); |
| bi23 = new BigInteger( |
| "597791300268191573513888045771594235932809890963138840086083595706565695943160293610527214057", |
| 10); |
| bi13 = new BigInteger( |
| "270307912162948508387666703213038600031041043966215279482940731158968434008", |
| 10); |
| bi12 = new BigInteger( |
| "15058244971895641717453176477697767050482947161656458456", 10); |
| |
| largePos = new BigInteger( |
| "834759814379857314986743298675687569845986736578576375675678998612743867438632986243982098437620983476924376", |
| 16); |
| smallPos = new BigInteger("48753269875973284765874598630960986276", 16); |
| largeNeg = new BigInteger( |
| "-878824397432651481891353247987891423768534321387864361143548364457698487264387568743568743265873246576467643756437657436587436", |
| 16); |
| smallNeg = new BigInteger("-567863254343798609857456273458769843", 16); |
| booleanPairs = new BigInteger[][] { { largePos, smallPos }, |
| { largePos, smallNeg }, { largeNeg, smallPos }, |
| { largeNeg, smallNeg } }; |
| } |
| |
| private void testDiv(BigInteger i1, BigInteger i2) { |
| BigInteger q = i1.divide(i2); |
| BigInteger r = i1.remainder(i2); |
| BigInteger[] temp = i1.divideAndRemainder(i2); |
| |
| assertTrue("divide and divideAndRemainder do not agree", q |
| .equals(temp[0])); |
| assertTrue("remainder and divideAndRemainder do not agree", r |
| .equals(temp[1])); |
| assertTrue("signum and equals(zero) do not agree on quotient", q |
| .signum() != 0 |
| || q.equals(zero)); |
| assertTrue("signum and equals(zero) do not agree on remainder", r |
| .signum() != 0 |
| || r.equals(zero)); |
| assertTrue("wrong sign on quotient", q.signum() == 0 |
| || q.signum() == i1.signum() * i2.signum()); |
| assertTrue("wrong sign on remainder", r.signum() == 0 |
| || r.signum() == i1.signum()); |
| assertTrue("remainder out of range", r.abs().compareTo(i2.abs()) < 0); |
| assertTrue("quotient too small", q.abs().add(one).multiply(i2.abs()) |
| .compareTo(i1.abs()) > 0); |
| assertTrue("quotient too large", q.abs().multiply(i2.abs()).compareTo( |
| i1.abs()) <= 0); |
| BigInteger p = q.multiply(i2); |
| BigInteger a = p.add(r); |
| assertTrue("(a/b)*b+(a%b) != a", a.equals(i1)); |
| try { |
| BigInteger mod = i1.mod(i2); |
| assertTrue("mod is negative", mod.signum() >= 0); |
| assertTrue("mod out of range", mod.abs().compareTo(i2.abs()) < 0); |
| assertTrue("positive remainder == mod", r.signum() < 0 |
| || r.equals(mod)); |
| assertTrue("negative remainder == mod - divisor", r.signum() >= 0 |
| || r.equals(mod.subtract(i2))); |
| } catch (ArithmeticException e) { |
| assertTrue("mod fails on negative divisor only", i2.signum() <= 0); |
| } |
| } |
| |
| private void testDivRanges(BigInteger i) { |
| BigInteger bound = i.multiply(two); |
| for (BigInteger j = bound.negate(); j.compareTo(bound) <= 0; j = j |
| .add(i)) { |
| BigInteger innerbound = j.add(two); |
| BigInteger k = j.subtract(two); |
| for (; k.compareTo(innerbound) <= 0; k = k.add(one)) { |
| testDiv(k, i); |
| } |
| } |
| } |
| |
| private boolean isPrime(long b) { |
| if (b == 2) { |
| return true; |
| } |
| // check for div by 2 |
| if ((b & 1L) == 0) { |
| return false; |
| } |
| long maxlen = ((long) Math.sqrt(b)) + 2; |
| for (long x = 3; x < maxlen; x += 2) { |
| if (b % x == 0) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private void testAllMults(BigInteger i1, BigInteger i2, BigInteger ans) { |
| assertTrue("i1*i2=ans", i1.multiply(i2).equals(ans)); |
| assertTrue("i2*i1=ans", i2.multiply(i1).equals(ans)); |
| assertTrue("-i1*i2=-ans", i1.negate().multiply(i2).equals(ans.negate())); |
| assertTrue("-i2*i1=-ans", i2.negate().multiply(i1).equals(ans.negate())); |
| assertTrue("i1*-i2=-ans", i1.multiply(i2.negate()).equals(ans.negate())); |
| assertTrue("i2*-i1=-ans", i2.multiply(i1.negate()).equals(ans.negate())); |
| assertTrue("-i1*-i2=ans", i1.negate().multiply(i2.negate()).equals(ans)); |
| assertTrue("-i2*-i1=ans", i2.negate().multiply(i1.negate()).equals(ans)); |
| } |
| |
| private void testAllDivs(BigInteger i1, BigInteger i2) { |
| testDiv(i1, i2); |
| testDiv(i1.negate(), i2); |
| testDiv(i1, i2.negate()); |
| testDiv(i1.negate(), i2.negate()); |
| } |
| } |