1 /* 2 * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 6473768 27 * @summary Tests of BigInteger.compareTo 28 * @author Joseph D. Darcy 29 */ 30 import java.math.*; 31 import static java.math.BigInteger.*; 32 33 public class CompareToTests { 34 private static int compareToTests() { 35 int failures = 0; 36 37 final BigInteger MINUS_ONE = BigInteger.ONE.negate(); 38 final BigInteger TWO_POW_126 = ONE.shiftLeft(126); 39 final BigInteger TWO_POW_127 = ONE.shiftLeft(127); 40 final BigInteger TWO_POW_128 = ONE.shiftLeft(128); 41 42 // First operand, second operand, expected compareTo result 43 BigInteger [][] testCases = { 44 // Basics 45 {valueOf(0), valueOf(0), ZERO}, 46 {valueOf(0), valueOf(1), MINUS_ONE}, 47 {valueOf(1), valueOf(2), MINUS_ONE}, 48 {valueOf(2), valueOf(1), ONE}, 49 {valueOf(10), valueOf(10), ZERO}, 50 51 // Various relative lengths of internal mag array. 52 {TWO_POW_127, TWO_POW_127, ZERO}, 53 {TWO_POW_127.negate(), TWO_POW_127, MINUS_ONE}, 54 55 {TWO_POW_128.or(TWO_POW_126), TWO_POW_128, ONE}, 56 {TWO_POW_128.or(TWO_POW_126), TWO_POW_128.negate(), ONE}, 57 58 {TWO_POW_128, TWO_POW_128.or(TWO_POW_126), MINUS_ONE}, 59 {TWO_POW_128.negate(), TWO_POW_128.or(TWO_POW_126), MINUS_ONE}, 60 61 {TWO_POW_127, TWO_POW_128, MINUS_ONE}, 62 {TWO_POW_127.negate(), TWO_POW_128, MINUS_ONE}, 63 64 {TWO_POW_128, TWO_POW_127, ONE}, 65 {TWO_POW_128.negate(), TWO_POW_127, MINUS_ONE}, 66 67 // Long boundary and near boundary values 68 {valueOf(Long.MAX_VALUE), valueOf(Long.MAX_VALUE), ZERO}, 69 {valueOf(Long.MAX_VALUE).negate(), valueOf(Long.MAX_VALUE), MINUS_ONE}, 70 71 {valueOf(Long.MAX_VALUE-1), valueOf(Long.MAX_VALUE), MINUS_ONE}, 72 {valueOf(Long.MAX_VALUE-1).negate(), valueOf(Long.MAX_VALUE), MINUS_ONE}, 73 74 {valueOf(Long.MIN_VALUE), valueOf(Long.MAX_VALUE), MINUS_ONE}, 75 {valueOf(Long.MIN_VALUE).negate(), valueOf(Long.MAX_VALUE), ONE}, 76 77 {valueOf(Long.MIN_VALUE+1), valueOf(Long.MAX_VALUE), MINUS_ONE}, 78 {valueOf(Long.MIN_VALUE+1).negate(), valueOf(Long.MAX_VALUE), ZERO}, 79 80 {valueOf(Long.MAX_VALUE), valueOf(Long.MIN_VALUE), ONE}, 81 {valueOf(Long.MAX_VALUE).negate(), valueOf(Long.MIN_VALUE), ONE}, 82 83 {valueOf(Long.MAX_VALUE-1), valueOf(Long.MIN_VALUE), ONE}, 84 {valueOf(Long.MAX_VALUE-1).negate(), valueOf(Long.MIN_VALUE), ONE}, 85 86 {valueOf(Long.MIN_VALUE), valueOf(Long.MIN_VALUE), ZERO}, 87 {valueOf(Long.MIN_VALUE).negate(), valueOf(Long.MIN_VALUE), ONE}, 88 89 {valueOf(Long.MIN_VALUE+1), valueOf(Long.MIN_VALUE), ONE}, 90 {valueOf(Long.MIN_VALUE+1).negate(), valueOf(Long.MIN_VALUE), ONE}, 91 }; 92 93 for (BigInteger[] testCase : testCases) { 94 BigInteger a = testCase[0]; 95 BigInteger a_negate = a.negate(); 96 BigInteger b = testCase[1]; 97 BigInteger b_negate = b.negate(); 98 int expected = testCase[2].intValue(); 99 100 failures += compareToTest(a, b, expected); 101 failures += compareToTest(a_negate, b_negate, -expected); 102 } 103 104 105 return failures; 106 } 107 108 private static int compareToTest(BigInteger a, BigInteger b, int expected) { 109 int result = a.compareTo(b); 110 int failed = (result==expected) ? 0 : 1; 111 if (failed == 1) { 112 System.err.println("(" + a + ").compareTo(" + b + ") => " + result + 113 "\n\tExpected " + expected); 114 } 115 return failed; 116 } 117 118 public static void main(String argv[]) { 119 int failures = 0; 120 121 failures += compareToTests(); 122 123 if (failures > 0) { 124 throw new RuntimeException("Incurred " + failures + 125 " failures while testing exact compareTo."); 126 } 127 } 128 }