| /* |
| * Copyright 2009 Google Inc. |
| * |
| * Licensed 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. |
| */ |
| |
| /* |
| * 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. |
| * |
| * INCLUDES MODIFICATIONS BY GOOGLE. |
| */ |
| /** |
| * author Elena Semukhina |
| */ |
| package com.google.gwt.emultest.java.math; |
| |
| import com.google.gwt.emultest.java.util.EmulTestBase; |
| |
| import java.math.BigInteger; |
| |
| /** |
| * Class: java.math.BigInteger Methods: bitLength, shiftLeft, shiftRight, |
| * clearBit, flipBit, setBit, testBit. |
| */ |
| public class BigIntegerOperateBitsTest extends EmulTestBase { |
| /** |
| * bitCount() of a negative number. |
| */ |
| public void testBitCountNeg() { |
| BigInteger aNumber = new BigInteger( |
| "-12378634756382937873487638746283767238657872368748726875"); |
| assertEquals(87, aNumber.bitCount()); |
| } |
| |
| /** |
| * bitCount() of a negative number. |
| */ |
| public void testBitCountPos() { |
| BigInteger aNumber = new BigInteger( |
| "12378634756343564757582937873487638746283767238657872368748726875"); |
| assertEquals(107, aNumber.bitCount()); |
| } |
| |
| /** |
| * bitCount() of zero. |
| */ |
| public void testBitCountZero() { |
| BigInteger aNumber = new BigInteger("0"); |
| assertEquals(0, aNumber.bitCount()); |
| } |
| |
| /** |
| * bitLength() of a negative number. |
| */ |
| public void testBitLengthNegative1() { |
| byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; |
| int aSign = -1; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertEquals(108, aNumber.bitLength()); |
| } |
| |
| /** |
| * bitLength() of a negative number with the leftmost bit set. |
| */ |
| public void testBitLengthNegative2() { |
| byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertEquals(96, aNumber.bitLength()); |
| } |
| |
| /** |
| * bitLength() of a negative number which is a power of 2. |
| */ |
| public void testBitLengthNegative3() { |
| byte aBytes[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertEquals(80, aNumber.bitLength()); |
| } |
| |
| /** |
| * bitLength() of a positive number. |
| */ |
| public void testBitLengthPositive1() { |
| byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91}; |
| int aSign = 1; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertEquals(108, aNumber.bitLength()); |
| } |
| |
| /** |
| * bitLength() of a positive number with the leftmost bit set. |
| */ |
| public void testBitLengthPositive2() { |
| byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertEquals(96, aNumber.bitLength()); |
| } |
| |
| /** |
| * bitLength() of a positive number which is a power of 2. |
| */ |
| public void testBitLengthPositive3() { |
| byte aBytes[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = 1; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertEquals(81, aNumber.bitLength()); |
| } |
| |
| /** |
| * bitLength() of zero. |
| */ |
| public void testBitLengthZero() { |
| BigInteger aNumber = new BigInteger("0"); |
| assertEquals(0, aNumber.bitLength()); |
| } |
| |
| /** |
| * clearBit(int n) of a negative n. |
| */ |
| public void testClearBitException() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = -7; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| try { |
| aNumber = aNumber.clearBit(number); |
| fail("ArithmeticException has not been caught"); |
| } catch (ArithmeticException e) { |
| assertEquals("Improper exception message", "Negative bit address", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * clearBit(int n) inside a negative number. |
| */ |
| public void testClearBitNegativeInside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 15; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, 92, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) inside a negative number. |
| */ |
| public void testClearBitNegativeInside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 44; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -62, -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * clearBit(2) in the negative number with all ones in bit representation. |
| */ |
| public void testClearBitNegativeInside3() { |
| String as = "-18446744073709551615"; |
| int number = 2; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.clearBit(number); |
| assertEquals(as, result.toString()); |
| } |
| |
| /** |
| * clearBit(0) in the negative number of length 1 with all ones in bit |
| * representation. the resulting number's length is 2. |
| */ |
| public void testClearBitNegativeInside4() { |
| String as = "-4294967295"; |
| String res = "-4294967296"; |
| int number = 0; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.clearBit(number); |
| assertEquals(res, result.toString()); |
| } |
| |
| /** |
| * clearBit(0) in the negative number of length 2 with all ones in bit |
| * representation. the resulting number's length is 3. |
| */ |
| public void testClearBitNegativeInside5() { |
| String as = "-18446744073709551615"; |
| String res = "-18446744073709551616"; |
| int number = 0; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.clearBit(number); |
| assertEquals(res, result.toString()); |
| } |
| |
| /** |
| * clearBit(int n) outside a negative number. |
| */ |
| public void testClearBitNegativeOutside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 150; |
| byte rBytes[] = { |
| -65, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4, |
| 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) outside a negative number. |
| */ |
| public void testClearBitNegativeOutside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 165; |
| byte rBytes[] = { |
| -33, -1, -1, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, |
| -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) inside a positive number. |
| */ |
| public void testClearBitPositiveInside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 20; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -31, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) inside a positive number. |
| */ |
| public void testClearBitPositiveInside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 17; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) inside a positive number. |
| */ |
| public void testClearBitPositiveInside3() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 45; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 13, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) inside a positive number. |
| */ |
| public void testClearBitPositiveInside4() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 50; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) inside a positive number. |
| */ |
| public void testClearBitPositiveInside5() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 63; |
| byte rBytes[] = {1, -128, 56, 100, -2, 52, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) outside a positive number. |
| */ |
| public void testClearBitPositiveOutside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 150; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) outside a positive number. |
| */ |
| public void testClearBitPositiveOutside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 191; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) the leftmost bit in a negative number. |
| */ |
| public void testClearBitTopNegative() { |
| byte aBytes[] = {1, -128, 56, 100, -15, 35, 26}; |
| int aSign = -1; |
| int number = 63; |
| byte rBytes[] = {-1, 127, -2, 127, -57, -101, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) outside zero. |
| */ |
| public void testClearBitZero() { |
| byte aBytes[] = {0}; |
| int aSign = 0; |
| int number = 0; |
| byte rBytes[] = {0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 0, result.signum()); |
| } |
| |
| /** |
| * clearBit(int n) outside zero. |
| */ |
| public void testClearBitZeroOutside1() { |
| byte aBytes[] = {0}; |
| int aSign = 0; |
| int number = 95; |
| byte rBytes[] = {0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.clearBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 0, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) of a negative n. |
| */ |
| public void testFlipBitException() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = -7; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| try { |
| aNumber = aNumber.flipBit(number); |
| fail("ArithmeticException has not been caught"); |
| } catch (ArithmeticException e) { |
| assertEquals("Improper exception message", "Negative bit address", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * flipBit(int n) the leftmost bit in a negative number. |
| */ |
| public void testFlipBitLeftmostNegative() { |
| byte aBytes[] = {1, -128, 56, 100, -15, 35, 26}; |
| int aSign = -1; |
| int number = 48; |
| byte rBytes[] = {-1, 127, -57, -101, 14, -36, -26, 49}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) the leftmost bit in a positive number. |
| */ |
| public void testFlipBitLeftmostPositive() { |
| byte aBytes[] = {1, -128, 56, 100, -15, 35, 26}; |
| int aSign = 1; |
| int number = 48; |
| byte rBytes[] = {0, -128, 56, 100, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) inside a negative number. |
| */ |
| public void testFlipBitNegativeInside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 15; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, 92, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) inside a negative number. |
| */ |
| public void testFlipBitNegativeInside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 45; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -14, -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) inside a negative number with all ones in bit representation. |
| */ |
| public void testFlipBitNegativeInside3() { |
| String as = "-18446744073709551615"; |
| String res = "-18446744073709551611"; |
| int number = 2; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.flipBit(number); |
| assertEquals(res, result.toString()); |
| } |
| |
| /** |
| * flipBit(0) in the negative number of length 1 with all ones in bit |
| * representation. the resulting number's length is 2. |
| */ |
| public void testFlipBitNegativeInside4() { |
| String as = "-4294967295"; |
| String res = "-4294967296"; |
| int number = 0; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.flipBit(number); |
| assertEquals(res, result.toString()); |
| } |
| |
| /** |
| * flipBit(0) in the negative number of length 2 with all ones in bit |
| * representation. the resulting number's length is 3. |
| */ |
| public void testFlipBitNegativeInside5() { |
| String as = "-18446744073709551615"; |
| String res = "-18446744073709551616"; |
| int number = 0; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.flipBit(number); |
| assertEquals(res, result.toString()); |
| } |
| |
| /** |
| * flipBit(int n) outside a negative number. |
| */ |
| public void testFlipBitNegativeOutside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 150; |
| byte rBytes[] = { |
| -65, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4, |
| 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) outside a negative number. |
| */ |
| public void testFlipBitNegativeOutside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 191; |
| byte rBytes[] = { |
| -1, 127, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, |
| 75, -90, -46, -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) inside a positive number. |
| */ |
| public void testFlipBitPositiveInside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 15; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, -93, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) inside a positive number. |
| */ |
| public void testFlipBitPositiveInside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 45; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 13, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) outside a positive number. |
| */ |
| public void testFlipBitPositiveOutside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 150; |
| byte rBytes[] = { |
| 64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, |
| 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) outside a positive number. |
| */ |
| public void testFlipBitPositiveOutside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 191; |
| byte rBytes[] = { |
| 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, |
| 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) zero. |
| */ |
| public void testFlipBitZero() { |
| byte aBytes[] = {0}; |
| int aSign = 0; |
| int number = 0; |
| byte rBytes[] = {1}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) outside zero. |
| */ |
| public void testFlipBitZeroOutside1() { |
| byte aBytes[] = {0}; |
| int aSign = 0; |
| int number = 62; |
| byte rBytes[] = {64, 0, 0, 0, 0, 0, 0, 0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue("incorrect value", resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * flipBit(int n) outside zero. |
| */ |
| public void testFlipBitZeroOutside2() { |
| byte aBytes[] = {0}; |
| int aSign = 0; |
| int number = 63; |
| byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.flipBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue("incorrect value", resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit: check the case when the number of bit to be set can be represented |
| * as n * 32 + 31, where n is an arbitrary integer. Here 191 = 5 * 32 + 31. |
| */ |
| public void testSetBitBug1331() { |
| BigInteger result = BigInteger.valueOf(0L).setBit(191); |
| assertEquals("incorrect value", |
| "3138550867693340381917894711603833208051177722232017256448", |
| result.toString()); |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) of a negative n. |
| */ |
| public void testSetBitException() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = -7; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| try { |
| aNumber = aNumber.setBit(number); |
| fail("ArithmeticException has not been caught"); |
| } catch (ArithmeticException e) { |
| assertEquals("Improper exception message", "Negative bit address", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * setBit(int n) the leftmost bit in a negative number. |
| */ |
| public void testSetBitLeftmostNegative() { |
| byte aBytes[] = {1, -128, 56, 100, -15, 35, 26}; |
| int aSign = -1; |
| int number = 48; |
| byte rBytes[] = {-1, 127, -57, -101, 14, -36, -26, 49}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) inside a negative number. |
| */ |
| public void testSetBitNegativeInside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 15; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) inside a negative number. |
| */ |
| public void testSetBitNegativeInside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 44; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) inside a negative number with all ones in bit representation. |
| */ |
| public void testSetBitNegativeInside3() { |
| String as = "-18446744073709551615"; |
| String res = "-18446744073709551611"; |
| int number = 2; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.setBit(number); |
| assertEquals(res, result.toString()); |
| } |
| |
| /** |
| * setBit(0) in the negative number of length 1 with all ones in bit |
| * representation. the resulting number's length is 2. |
| */ |
| public void testSetBitNegativeInside4() { |
| String as = "-4294967295"; |
| int number = 0; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.setBit(number); |
| assertEquals(as, result.toString()); |
| } |
| |
| /** |
| * setBit(0) in the negative number of length 2 with all ones in bit |
| * representation. the resulting number's length is 3. |
| */ |
| public void testSetBitNegativeInside5() { |
| String as = "-18446744073709551615"; |
| int number = 0; |
| BigInteger aNumber = new BigInteger(as); |
| BigInteger result = aNumber.setBit(number); |
| assertEquals(as, result.toString()); |
| } |
| |
| /** |
| * setBit(int n) outside a negative number. |
| */ |
| public void testSetBitNegativeOutside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 150; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) outside a negative number. |
| */ |
| public void testSetBitNegativeOutside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 191; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) inside a positive number. |
| */ |
| public void testSetBitPositiveInside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 20; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) inside a positive number. |
| */ |
| public void testSetBitPositiveInside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 17; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -13, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) inside a positive number. |
| */ |
| public void testSetBitPositiveInside3() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 45; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) inside a positive number. |
| */ |
| public void testSetBitPositiveInside4() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 50; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 93, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) outside a positive number. |
| */ |
| public void testSetBitPositiveOutside1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 150; |
| byte rBytes[] = { |
| 64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, |
| 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) outside a positive number. |
| */ |
| public void testSetBitPositiveOutside2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 223; |
| byte rBytes[] = { |
| 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -128, 56, 100, |
| -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) the leftmost bit in a positive number. |
| */ |
| public void testSetBitTopPositive() { |
| byte aBytes[] = {1, -128, 56, 100, -15, 35, 26}; |
| int aSign = 1; |
| int number = 63; |
| byte rBytes[] = {0, -128, 1, -128, 56, 100, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) outside zero. |
| */ |
| public void testSetBitZero() { |
| byte aBytes[] = {0}; |
| int aSign = 0; |
| int number = 0; |
| byte rBytes[] = {1}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * setBit(int n) outside zero. |
| */ |
| public void testSetBitZeroOutside1() { |
| byte aBytes[] = {0}; |
| int aSign = 0; |
| int number = 95; |
| byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.setBit(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftLeft(int n), n = 0. |
| */ |
| public void testShiftLeft1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 0; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftLeft(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftLeft(int n), n < 0. |
| */ |
| public void testShiftLeft2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = -27; |
| byte rBytes[] = {48, 7, 12, -97, -42, -117, 37, -85, 96}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftLeft(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftLeft(int n) a positive number, n > 0. |
| */ |
| public void testShiftLeft3() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 27; |
| byte rBytes[] = { |
| 12, 1, -61, 39, -11, -94, -55, 106, -40, 31, -119, 24, -48, 0, 0, 0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftLeft(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftLeft(int n) a positive number, n > 0. |
| */ |
| public void testShiftLeft4() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 45; |
| byte rBytes[] = { |
| 48, 7, 12, -97, -42, -117, 37, -85, 96, 126, 36, 99, 64, 0, 0, 0, 0, 0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftLeft(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftLeft(int n) a negative number, n > 0. |
| */ |
| public void testShiftLeft5() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 45; |
| byte rBytes[] = { |
| -49, -8, -13, 96, 41, 116, -38, 84, -97, -127, -37, -100, -64, 0, 0, 0, |
| 0, 0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftLeft(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * shiftRight(int n), n = 0. |
| */ |
| public void testShiftRight1() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 0; |
| byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftRight(int n), n < 0. |
| */ |
| public void testShiftRight2() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = -27; |
| byte rBytes[] = { |
| 12, 1, -61, 39, -11, -94, -55, 106, -40, 31, -119, 24, -48, 0, 0, 0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftRight(int n), 0 < n < 32. |
| */ |
| public void testShiftRight3() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 27; |
| byte rBytes[] = {48, 7, 12, -97, -42, -117, 37, -85, 96}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftRight(int n), n > 32. |
| */ |
| public void testShiftRight4() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 45; |
| byte rBytes[] = {12, 1, -61, 39, -11, -94, -55}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 1, result.signum()); |
| } |
| |
| /** |
| * shiftRight(int n), n is greater than bitLength(). |
| */ |
| public void testShiftRight5() { |
| byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 300; |
| byte rBytes[] = {0}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", 0, result.signum()); |
| } |
| |
| /** |
| * shiftRight a negative number; shift distance is NOT multiple of 32; shifted |
| * bits are NOT zeroes. |
| */ |
| public void testShiftRightNegNonZeroes() { |
| byte aBytes[] = { |
| 1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| int number = 68; |
| byte rBytes[] = {-25, -4, 121, -80, 20, -70, 109, 42}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * shiftRight a negative number; shift distance is multiple of 32; shifted |
| * bits are NOT zeroes. |
| */ |
| public void testShiftRightNegNonZeroesMul32() { |
| byte aBytes[] = { |
| 1, -128, 56, 100, -2, -76, 89, 45, 91, 1, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| int number = 64; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * shiftRight a negative number; shift distance is NOT multiple of 32; shifted |
| * bits are zeroes. |
| */ |
| public void testShiftRightNegZeroes() { |
| byte aBytes[] = { |
| 1, -128, 56, 100, -2, -76, 89, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| int number = 68; |
| byte rBytes[] = {-25, -4, 121, -80, 20, -70, 109, 48}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * shiftRight a negative number; shift distance is multiple of 32; shifted |
| * bits are zeroes. |
| */ |
| public void testShiftRightNegZeroesMul32() { |
| byte aBytes[] = { |
| 1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0, 0, 0, 0, 0, 0, 0}; |
| int aSign = -1; |
| int number = 64; |
| byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -91}; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| BigInteger result = aNumber.shiftRight(number); |
| byte resBytes[] = new byte[rBytes.length]; |
| resBytes = result.toByteArray(); |
| for (int i = 0; i < resBytes.length; i++) { |
| assertTrue(resBytes[i] == rBytes[i]); |
| } |
| assertEquals("incorrect sign", -1, result.signum()); |
| } |
| |
| /** |
| * testBit(int n) of a negative n. |
| */ |
| public void testTestBitException() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = -7; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| try { |
| aNumber.testBit(number); |
| fail("ArithmeticException has not been caught"); |
| } catch (ArithmeticException e) { |
| assertEquals("Improper exception message", "Negative bit address", |
| e.getMessage()); |
| } |
| } |
| |
| /** |
| * testBit(int n) of a negative number. |
| */ |
| public void testTestBitNegative1() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 7; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertTrue(aNumber.testBit(number)); |
| } |
| |
| /** |
| * testBit(int n) of a positive n. |
| */ |
| public void testTestBitNegative2() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 45; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertTrue(!aNumber.testBit(number)); |
| } |
| |
| /** |
| * testBit(int n) of a positive n, n > bitLength(). |
| */ |
| public void testTestBitNegative3() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = -1; |
| int number = 300; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertTrue(aNumber.testBit(number)); |
| } |
| |
| /** |
| * testBit(int n) of a positive number. |
| */ |
| public void testTestBitPositive1() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 7; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertTrue(!aNumber.testBit(number)); |
| } |
| |
| /** |
| * testBit(int n) of a positive number. |
| */ |
| public void testTestBitPositive2() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 45; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertTrue(aNumber.testBit(number)); |
| } |
| |
| /** |
| * testBit(int n) of a positive number, n > bitLength(). |
| */ |
| public void testTestBitPositive3() { |
| byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26}; |
| int aSign = 1; |
| int number = 300; |
| BigInteger aNumber = new BigInteger(aSign, aBytes); |
| assertTrue(!aNumber.testBit(number)); |
| } |
| } |