You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by te...@apache.org on 2006/03/29 11:01:07 UTC
svn commit: r389715 [4/12] - in /incubator/harmony/enhanced/classlib/trunk:
make/ modules/math/META-INF/ modules/math/make/ modules/math/make/common/
modules/math/src/main/java/java/math/ modules/math/src/test/java/org/
modules/math/src/test/java/org/a...
Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAddTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAddTest.java?rev=389715&r1=389571&r2=389715&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAddTest.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAddTest.java Wed Mar 29 01:01:04 2006
@@ -1,497 +1,497 @@
-/*
- * Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
- *
- * 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.
- */
-/**
- * @author Elena Semukhina
- * @version $Revision: 1.5.6.2 $
- */
-
-package java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger
- * Method: add
- */
-public class BigIntegerAddTest extends TestCase {
- /**
- * Add two positive numbers of the same length
- */
- public void testCase1() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two negative numbers of the same length
- */
- public void testCase2() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Add two numbers of the same length.
- * The first one is positive and the second is negative.
- * The first one is greater in absolute value.
- */
- public void testCase3() {
- byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
- int aSign = 1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two numbers of the same length.
- * The first one is negative and the second is positive.
- * The first one is greater in absolute value.
- */
- public void testCase4() {
- byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
- int aSign = -1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Add two numbers of the same length.
- * The first is positive and the second is negative.
- * The first is less in absolute value.
- */
- public void testCase5() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
- int aSign = 1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Add two numbers of the same length.
- * The first one is negative and the second is positive.
- * The first one is less in absolute value.
- */
- public void testCase6() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
- int aSign = -1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two positive numbers of different length.
- * The first is longer.
- */
- public void testCase7() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two positive numbers of different length.
- * The second is longer.
- */
- public void testCase8() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
- BigInteger aNumber = new BigInteger(aBytes);
- BigInteger bNumber = new BigInteger(bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two negative numbers of different length.
- * The first is longer.
- */
- public void testCase9() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Add two negative numbers of different length.
- * The second is longer.
- */
- public void testCase10() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Add two numbers of different length and sign.
- * The first is positive.
- * The first is longer.
- */
- public void testCase11() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two numbers of different length and sign.
- * The first is positive.
- * The second is longer.
- */
- public void testCase12() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Add two numbers of different length and sign.
- * The first is negative.
- * The first is longer.
- */
- public void testCase13() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Add two numbers of different length and sign.
- * The first is negative.
- * The second is longer.
- */
- public void testCase14() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two equal numbers of different signs
- */
- public void testCase15() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {0};
- int aSign = -1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * Add zero to a number
- */
- public void testCase16() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {0};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add a number to zero
- */
- public void testCase17() {
- byte aBytes[] = {0};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add zero to zero
- */
- public void testCase18() {
- byte aBytes[] = {0};
- byte bBytes[] = {0};
- byte rBytes[] = {0};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * Add ZERO to a number
- */
- public void testCase19() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add a number to zero
- */
- public void testCase20() {
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int bSign = 1;
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add ZERO to ZERO
- */
- public void testCase21() {
- byte rBytes[] = {0};
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * Add ONE to ONE
- */
- public void testCase22() {
- byte rBytes[] = {2};
- BigInteger aNumber = BigInteger.ONE;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Add two numbers so that carry is 1
- */
- public void testCase23() {
- byte aBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- byte bBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-}
+/*
+ * Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ * 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.
+ */
+/**
+ * @author Elena Semukhina
+ * @version $Revision: 1.5.6.2 $
+ */
+
+package org.apache.harmony.tests.math;
+
+import junit.framework.TestCase;
+import java.math.BigInteger;
+
+/**
+ * Class: java.math.BigInteger
+ * Method: add
+ */
+public class BigIntegerAddTest extends TestCase {
+ /**
+ * Add two positive numbers of the same length
+ */
+ public void testCase1() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+ byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ int aSign = 1;
+ int bSign = 1;
+ byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two negative numbers of the same length
+ */
+ public void testCase2() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+ byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ int aSign = -1;
+ int bSign = -1;
+ byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Add two numbers of the same length.
+ * The first one is positive and the second is negative.
+ * The first one is greater in absolute value.
+ */
+ public void testCase3() {
+ byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
+ int aSign = 1;
+ int bSign = -1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two numbers of the same length.
+ * The first one is negative and the second is positive.
+ * The first one is greater in absolute value.
+ */
+ public void testCase4() {
+ byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
+ int aSign = -1;
+ int bSign = 1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Add two numbers of the same length.
+ * The first is positive and the second is negative.
+ * The first is less in absolute value.
+ */
+ public void testCase5() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
+ byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
+ int aSign = 1;
+ int bSign = -1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Add two numbers of the same length.
+ * The first one is negative and the second is positive.
+ * The first one is less in absolute value.
+ */
+ public void testCase6() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
+ byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
+ int aSign = -1;
+ int bSign = 1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two positive numbers of different length.
+ * The first is longer.
+ */
+ public void testCase7() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ int aSign = 1;
+ int bSign = 1;
+ byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two positive numbers of different length.
+ * The second is longer.
+ */
+ public void testCase8() {
+ byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ int aSign = 1;
+ int bSign = 1;
+ byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
+ BigInteger aNumber = new BigInteger(aBytes);
+ BigInteger bNumber = new BigInteger(bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two negative numbers of different length.
+ * The first is longer.
+ */
+ public void testCase9() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ int aSign = -1;
+ int bSign = -1;
+ byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Add two negative numbers of different length.
+ * The second is longer.
+ */
+ public void testCase10() {
+ byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ int aSign = -1;
+ int bSign = -1;
+ byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Add two numbers of different length and sign.
+ * The first is positive.
+ * The first is longer.
+ */
+ public void testCase11() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ int aSign = 1;
+ int bSign = -1;
+ byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two numbers of different length and sign.
+ * The first is positive.
+ * The second is longer.
+ */
+ public void testCase12() {
+ byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ int aSign = 1;
+ int bSign = -1;
+ byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Add two numbers of different length and sign.
+ * The first is negative.
+ * The first is longer.
+ */
+ public void testCase13() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ int aSign = -1;
+ int bSign = 1;
+ byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Add two numbers of different length and sign.
+ * The first is negative.
+ * The second is longer.
+ */
+ public void testCase14() {
+ byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+ int aSign = -1;
+ int bSign = 1;
+ byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two equal numbers of different signs
+ */
+ public void testCase15() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte rBytes[] = {0};
+ int aSign = -1;
+ int bSign = 1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * Add zero to a number
+ */
+ public void testCase16() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte bBytes[] = {0};
+ byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ int aSign = 1;
+ int bSign = 1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add a number to zero
+ */
+ public void testCase17() {
+ byte aBytes[] = {0};
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ int aSign = 1;
+ int bSign = 1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add zero to zero
+ */
+ public void testCase18() {
+ byte aBytes[] = {0};
+ byte bBytes[] = {0};
+ byte rBytes[] = {0};
+ int aSign = 1;
+ int bSign = 1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * Add ZERO to a number
+ */
+ public void testCase19() {
+ byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ int aSign = 1;
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = BigInteger.ZERO;
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add a number to zero
+ */
+ public void testCase20() {
+ byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
+ int bSign = 1;
+ BigInteger aNumber = BigInteger.ZERO;
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add ZERO to ZERO
+ */
+ public void testCase21() {
+ byte rBytes[] = {0};
+ BigInteger aNumber = BigInteger.ZERO;
+ BigInteger bNumber = BigInteger.ZERO;
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * Add ONE to ONE
+ */
+ public void testCase22() {
+ byte rBytes[] = {2};
+ BigInteger aNumber = BigInteger.ONE;
+ BigInteger bNumber = BigInteger.ONE;
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Add two numbers so that carry is 1
+ */
+ public void testCase23() {
+ byte aBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+ byte bBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
+ int aSign = 1;
+ int bSign = 1;
+ byte rBytes[] = {1, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -2};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.add(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+}
Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAndTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAndTest.java?rev=389715&r1=389571&r2=389715&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAndTest.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/math/BigIntegerAndTest.java Wed Mar 29 01:01:04 2006
@@ -1,432 +1,432 @@
-/*
- * Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
- *
- * 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.
- */
-/**
- * @author Elena Semukhina
- * @version $Revision: 1.3.6.2 $
- */
-
-package java.math;
-
-import junit.framework.TestCase;
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger
- * Method: and
- */
-public class BigIntegerAndTest extends TestCase {
- /**
- * And for zero and a positive number
- */
- public void testZeroPos() {
- byte aBytes[] = {0};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 0;
- int bSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * And for zero and a negative number
- */
- public void testZeroNeg() {
- byte aBytes[] = {0};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 0;
- int bSign = -1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * And for a positive number and zero
- */
- public void testPosZero() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {0};
- int aSign = 1;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * And for a negative number and zero
- */
- public void testNegPos() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {0};
- int aSign = -1;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * And for zero and zero
- */
- public void testZeroZero() {
- byte aBytes[] = {0};
- byte bBytes[] = {0};
- int aSign = 0;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * And for zero and one
- */
- public void testZeroOne() {
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.and(bNumber);
- assertTrue(result.equals(BigInteger.ZERO));
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * And for one and one
- */
- public void testOneOne() {
- BigInteger aNumber = BigInteger.ONE;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.and(bNumber);
- assertTrue(result.equals(BigInteger.ONE));
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for two positive numbers of the same length
- */
- public void testPosPosSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -128, 56, 100, 4, 4, 17, 37, 16, 1, 64, 1, 10, 3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for two positive numbers; the first is longer
- */
- public void testPosPosFirstLonger() {
- byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for two positive numbers; the first is shorter
- */
- public void testPosPosFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for two negative numbers of the same length
- */
- public void testNegNegSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-1, 1, 2, 3, 3, 0, 65, -96, -48, -124, -60, 12, -40, -31, 97};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * And for two negative numbers; the first is longer
- */
- public void testNegNegFirstLonger() {
- byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * And for two negative numbers; the first is shorter
- */
- public void testNegNegFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * And for two numbers of different signs and the same length
- */
- public void testPosNegSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {0, -6, -80, 72, 8, 75, 2, -79, 34, 16, -119};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for two numbers of different signs and the same length
- */
- public void testNegPosSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {0, -2, 125, -60, -104, 1, 10, 6, 2, 32, 56, 2, 4, 4, 21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for a negative and a positive numbers; the first is longer
- */
- public void testNegPosFirstLonger() {
- byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for a negative and a positive numbers; the first is shorter
- */
- public void testNegPosFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for a positive and a negative numbers; the first is longer
- */
- public void testPosNegFirstLonger() {
- byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * And for a positive and a negative numbers; the first is shorter
- */
- public void testPosNegFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * Test for a special case
- */
- public void testSpecialCase1() {
- byte aBytes[] = {-1, -1, -1, -1};
- byte bBytes[] = {5, -4, -3, -2};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-1, 0, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * Test for a special case
- */
- public void testSpecialCase2() {
- byte aBytes[] = {-51};
- byte bBytes[] = {-52, -51, -50, -49, -48};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {0, -52, -51, -50, -49, 16};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for(int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-}
+/*
+ * Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ * 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.
+ */
+/**
+ * @author Elena Semukhina
+ * @version $Revision: 1.3.6.2 $
+ */
+
+package org.apache.harmony.tests.math;
+
+import junit.framework.TestCase;
+import java.math.BigInteger;
+
+/**
+ * Class: java.math.BigInteger
+ * Method: and
+ */
+public class BigIntegerAndTest extends TestCase {
+ /**
+ * And for zero and a positive number
+ */
+ public void testZeroPos() {
+ byte aBytes[] = {0};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = 0;
+ int bSign = 1;
+ byte rBytes[] = {0};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * And for zero and a negative number
+ */
+ public void testZeroNeg() {
+ byte aBytes[] = {0};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = 0;
+ int bSign = -1;
+ byte rBytes[] = {0};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * And for a positive number and zero
+ */
+ public void testPosZero() {
+ byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ byte bBytes[] = {0};
+ int aSign = 1;
+ int bSign = 0;
+ byte rBytes[] = {0};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * And for a negative number and zero
+ */
+ public void testNegPos() {
+ byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ byte bBytes[] = {0};
+ int aSign = -1;
+ int bSign = 0;
+ byte rBytes[] = {0};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * And for zero and zero
+ */
+ public void testZeroZero() {
+ byte aBytes[] = {0};
+ byte bBytes[] = {0};
+ int aSign = 0;
+ int bSign = 0;
+ byte rBytes[] = {0};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * And for zero and one
+ */
+ public void testZeroOne() {
+ BigInteger aNumber = BigInteger.ZERO;
+ BigInteger bNumber = BigInteger.ONE;
+ BigInteger result = aNumber.and(bNumber);
+ assertTrue(result.equals(BigInteger.ZERO));
+ assertTrue("incorrect sign", result.signum() == 0);
+ }
+
+ /**
+ * And for one and one
+ */
+ public void testOneOne() {
+ BigInteger aNumber = BigInteger.ONE;
+ BigInteger bNumber = BigInteger.ONE;
+ BigInteger result = aNumber.and(bNumber);
+ assertTrue(result.equals(BigInteger.ONE));
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for two positive numbers of the same length
+ */
+ public void testPosPosSameLength() {
+ byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = 1;
+ int bSign = 1;
+ byte rBytes[] = {0, -128, 56, 100, 4, 4, 17, 37, 16, 1, 64, 1, 10, 3};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for two positive numbers; the first is longer
+ */
+ public void testPosPosFirstLonger() {
+ byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = 1;
+ int bSign = 1;
+ byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for two positive numbers; the first is shorter
+ */
+ public void testPosPosFirstShorter() {
+ byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ int aSign = 1;
+ int bSign = 1;
+ byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for two negative numbers of the same length
+ */
+ public void testNegNegSameLength() {
+ byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = -1;
+ int bSign = -1;
+ byte rBytes[] = {-1, 1, 2, 3, 3, 0, 65, -96, -48, -124, -60, 12, -40, -31, 97};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * And for two negative numbers; the first is longer
+ */
+ public void testNegNegFirstLonger() {
+ byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = -1;
+ int bSign = -1;
+ byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * And for two negative numbers; the first is shorter
+ */
+ public void testNegNegFirstShorter() {
+ byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ int aSign = -1;
+ int bSign = -1;
+ byte rBytes[] = {-1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88, -88, 16, 73};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * And for two numbers of different signs and the same length
+ */
+ public void testPosNegSameLength() {
+ byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = 1;
+ int bSign = -1;
+ byte rBytes[] = {0, -6, -80, 72, 8, 75, 2, -79, 34, 16, -119};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for two numbers of different signs and the same length
+ */
+ public void testNegPosSameLength() {
+ byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = -1;
+ int bSign = 1;
+ byte rBytes[] = {0, -2, 125, -60, -104, 1, 10, 6, 2, 32, 56, 2, 4, 4, 21};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for a negative and a positive numbers; the first is longer
+ */
+ public void testNegPosFirstLonger() {
+ byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = -1;
+ int bSign = 1;
+ byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for a negative and a positive numbers; the first is shorter
+ */
+ public void testNegPosFirstShorter() {
+ byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ int aSign = -1;
+ int bSign = 1;
+ byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for a positive and a negative numbers; the first is longer
+ */
+ public void testPosNegFirstLonger() {
+ byte aBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ int aSign = 1;
+ int bSign = -1;
+ byte rBytes[] = {0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31, -95};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * And for a positive and a negative numbers; the first is shorter
+ */
+ public void testPosNegFirstShorter() {
+ byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+ byte bBytes[] = {-128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87, -25, -75};
+ int aSign = 1;
+ int bSign = -1;
+ byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+
+ /**
+ * Test for a special case
+ */
+ public void testSpecialCase1() {
+ byte aBytes[] = {-1, -1, -1, -1};
+ byte bBytes[] = {5, -4, -3, -2};
+ int aSign = -1;
+ int bSign = -1;
+ byte rBytes[] = {-1, 0, 0, 0, 0};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == -1);
+ }
+
+ /**
+ * Test for a special case
+ */
+ public void testSpecialCase2() {
+ byte aBytes[] = {-51};
+ byte bBytes[] = {-52, -51, -50, -49, -48};
+ int aSign = -1;
+ int bSign = 1;
+ byte rBytes[] = {0, -52, -51, -50, -49, 16};
+ BigInteger aNumber = new BigInteger(aSign, aBytes);
+ BigInteger bNumber = new BigInteger(bSign, bBytes);
+ BigInteger result = aNumber.and(bNumber);
+ byte resBytes[] = new byte[rBytes.length];
+ resBytes = result.toByteArray();
+ for(int i = 0; i < resBytes.length; i++) {
+ assertTrue(resBytes[i] == rBytes[i]);
+ }
+ assertTrue("incorrect sign", result.signum() == 1);
+ }
+}