001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: /**
018: * @author Elena Semukhina
019: * @version $Revision$
020: */package org.apache.harmony.tests.java.math;
021:
022: import junit.framework.TestCase;
023: import java.math.BigInteger;
024:
025: /**
026: * Class: java.math.BigInteger
027: * Method: xor
028: */
029: public class BigIntegerXorTest extends TestCase {
030: /**
031: * Xor for zero and a positive number
032: */
033: public void testZeroPos() {
034: String numA = "0";
035: String numB = "27384627835298756289327365";
036: String res = "27384627835298756289327365";
037: BigInteger aNumber = new BigInteger(numA);
038: BigInteger bNumber = new BigInteger(numB);
039: BigInteger result = aNumber.xor(bNumber);
040: assertTrue(res.equals(result.toString()));
041: }
042:
043: /**
044: * Xor for zero and a negative number
045: */
046: public void testZeroNeg() {
047: String numA = "0";
048: String numB = "-27384627835298756289327365";
049: String res = "-27384627835298756289327365";
050: BigInteger aNumber = new BigInteger(numA);
051: BigInteger bNumber = new BigInteger(numB);
052: BigInteger result = aNumber.xor(bNumber);
053: assertTrue(res.equals(result.toString()));
054: }
055:
056: /**
057: * Xor for a positive number and zero
058: */
059: public void testPosZero() {
060: String numA = "27384627835298756289327365";
061: String numB = "0";
062: String res = "27384627835298756289327365";
063: BigInteger aNumber = new BigInteger(numA);
064: BigInteger bNumber = new BigInteger(numB);
065: BigInteger result = aNumber.xor(bNumber);
066: assertTrue(res.equals(result.toString()));
067: }
068:
069: /**
070: * Xor for a negative number and zero
071: */
072: public void testNegPos() {
073: String numA = "-27384627835298756289327365";
074: String numB = "0";
075: String res = "-27384627835298756289327365";
076: BigInteger aNumber = new BigInteger(numA);
077: BigInteger bNumber = new BigInteger(numB);
078: BigInteger result = aNumber.xor(bNumber);
079: assertTrue(res.equals(result.toString()));
080: }
081:
082: /**
083: * Xor for zero and zero
084: */
085: public void testZeroZero() {
086: String numA = "0";
087: String numB = "0";
088: String res = "0";
089: BigInteger aNumber = new BigInteger(numA);
090: BigInteger bNumber = new BigInteger(numB);
091: BigInteger result = aNumber.xor(bNumber);
092: assertTrue(res.equals(result.toString()));
093: }
094:
095: /**
096: * Xor for zero and one
097: */
098: public void testZeroOne() {
099: String numA = "0";
100: String numB = "1";
101: String res = "1";
102: BigInteger aNumber = new BigInteger(numA);
103: BigInteger bNumber = new BigInteger(numB);
104: BigInteger result = aNumber.xor(bNumber);
105: assertTrue(res.equals(result.toString()));
106: }
107:
108: /**
109: * Xor for one and one
110: */
111: public void testOneOne() {
112: String numA = "1";
113: String numB = "1";
114: String res = "0";
115: BigInteger aNumber = new BigInteger(numA);
116: BigInteger bNumber = new BigInteger(numB);
117: BigInteger result = aNumber.xor(bNumber);
118: assertTrue(res.equals(result.toString()));
119: }
120:
121: /**
122: * Xor for two positive numbers of the same length
123: */
124: public void testPosPosSameLength() {
125: String numA = "283746278342837476784564875684767";
126: String numB = "293478573489347658763745839457637";
127: String res = "71412358434940908477702819237626";
128: BigInteger aNumber = new BigInteger(numA);
129: BigInteger bNumber = new BigInteger(numB);
130: BigInteger result = aNumber.xor(bNumber);
131: assertTrue(res.equals(result.toString()));
132: }
133:
134: /**
135: * Xor for two positive numbers; the first is longer
136: */
137: public void testPosPosFirstLonger() {
138: String numA = "2837462783428374767845648748973847593874837948575684767";
139: String numB = "293478573489347658763745839457637";
140: String res = "2837462783428374767845615168483972194300564226167553530";
141: BigInteger aNumber = new BigInteger(numA);
142: BigInteger bNumber = new BigInteger(numB);
143: BigInteger result = aNumber.xor(bNumber);
144: assertTrue(res.equals(result.toString()));
145: }
146:
147: /**
148: * Xor for two positive numbers; the first is shorter
149: */
150: public void testPosPosFirstShorter() {
151: String numA = "293478573489347658763745839457637";
152: String numB = "2837462783428374767845648748973847593874837948575684767";
153: String res = "2837462783428374767845615168483972194300564226167553530";
154: BigInteger aNumber = new BigInteger(numA);
155: BigInteger bNumber = new BigInteger(numB);
156: BigInteger result = aNumber.xor(bNumber);
157: assertTrue(res.equals(result.toString()));
158: }
159:
160: /**
161: * Xor for two negative numbers of the same length
162: */
163: public void testNegNegSameLength() {
164: String numA = "-283746278342837476784564875684767";
165: String numB = "-293478573489347658763745839457637";
166: String res = "71412358434940908477702819237626";
167: BigInteger aNumber = new BigInteger(numA);
168: BigInteger bNumber = new BigInteger(numB);
169: BigInteger result = aNumber.xor(bNumber);
170: assertTrue(res.equals(result.toString()));
171: }
172:
173: /**
174: * Xor for two negative numbers; the first is longer
175: */
176: public void testNegNegFirstLonger() {
177: String numA = "-2837462783428374767845648748973847593874837948575684767";
178: String numB = "-293478573489347658763745839457637";
179: String res = "2837462783428374767845615168483972194300564226167553530";
180: BigInteger aNumber = new BigInteger(numA);
181: BigInteger bNumber = new BigInteger(numB);
182: BigInteger result = aNumber.xor(bNumber);
183: assertTrue(res.equals(result.toString()));
184: }
185:
186: /**
187: * Xor for two negative numbers; the first is shorter
188: */
189: public void testNegNegFirstShorter() {
190: String numA = "293478573489347658763745839457637";
191: String numB = "2837462783428374767845648748973847593874837948575684767";
192: String res = "2837462783428374767845615168483972194300564226167553530";
193: BigInteger aNumber = new BigInteger(numA);
194: BigInteger bNumber = new BigInteger(numB);
195: BigInteger result = aNumber.xor(bNumber);
196: assertTrue(res.equals(result.toString()));
197: }
198:
199: /**
200: * Xor for two numbers of different signs and the same length
201: */
202: public void testPosNegSameLength() {
203: String numA = "283746278342837476784564875684767";
204: String numB = "-293478573489347658763745839457637";
205: String res = "-71412358434940908477702819237628";
206: BigInteger aNumber = new BigInteger(numA);
207: BigInteger bNumber = new BigInteger(numB);
208: BigInteger result = aNumber.xor(bNumber);
209: assertTrue(res.equals(result.toString()));
210: }
211:
212: /**
213: * Xor for two numbers of different signs and the same length
214: */
215: public void testNegPosSameLength() {
216: String numA = "-283746278342837476784564875684767";
217: String numB = "293478573489347658763745839457637";
218: String res = "-71412358434940908477702819237628";
219: BigInteger aNumber = new BigInteger(numA);
220: BigInteger bNumber = new BigInteger(numB);
221: BigInteger result = aNumber.xor(bNumber);
222: assertTrue(res.equals(result.toString()));
223: }
224:
225: /**
226: * Xor for a negative and a positive numbers; the first is longer
227: */
228: public void testNegPosFirstLonger() {
229: String numA = "-2837462783428374767845648748973847593874837948575684767";
230: String numB = "293478573489347658763745839457637";
231: String res = "-2837462783428374767845615168483972194300564226167553532";
232: BigInteger aNumber = new BigInteger(numA);
233: BigInteger bNumber = new BigInteger(numB);
234: BigInteger result = aNumber.xor(bNumber);
235: assertTrue(res.equals(result.toString()));
236: }
237:
238: /**
239: * Xor for two negative numbers; the first is shorter
240: */
241: public void testNegPosFirstShorter() {
242: String numA = "-293478573489347658763745839457637";
243: String numB = "2837462783428374767845648748973847593874837948575684767";
244: String res = "-2837462783428374767845615168483972194300564226167553532";
245: BigInteger aNumber = new BigInteger(numA);
246: BigInteger bNumber = new BigInteger(numB);
247: BigInteger result = aNumber.xor(bNumber);
248: assertTrue(res.equals(result.toString()));
249: }
250:
251: /**
252: * Xor for a positive and a negative numbers; the first is longer
253: */
254: public void testPosNegFirstLonger() {
255: String numA = "2837462783428374767845648748973847593874837948575684767";
256: String numB = "-293478573489347658763745839457637";
257: String res = "-2837462783428374767845615168483972194300564226167553532";
258: BigInteger aNumber = new BigInteger(numA);
259: BigInteger bNumber = new BigInteger(numB);
260: BigInteger result = aNumber.xor(bNumber);
261: assertTrue(res.equals(result.toString()));
262: }
263:
264: /**
265: * Xor for a positive and a negative number; the first is shorter
266: */
267: public void testPosNegFirstShorter() {
268: String numA = "293478573489347658763745839457637";
269: String numB = "-2837462783428374767845648748973847593874837948575684767";
270: String res = "-2837462783428374767845615168483972194300564226167553532";
271: BigInteger aNumber = new BigInteger(numA);
272: BigInteger bNumber = new BigInteger(numB);
273: BigInteger result = aNumber.xor(bNumber);
274: assertTrue(res.equals(result.toString()));
275: }
276: }
|