--- /dev/null 2012-01-10 11:47:00.807870926 -0800 +++ new/test/java/lang/Long/Unsigned.java 2012-01-20 17:55:56.000000000 -0800 @@ -0,0 +1,388 @@ +/* + * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 4504839 4215269 6322074 + * @summary Basic tests for unsigned operations + * @author Joseph D. Darcy + */ + +import java.math.*; + +public class Unsigned { + public static void main(String... args) { + int errors = 0; + + errors += testRoundtrip(); + errors += testByteToUnsignedLong(); + errors += testShortToUnsignedLong(); + errors += testUnsignedCompare(); + errors += testToStringUnsigned(); + errors += testParseUnsignedLong(); + errors += testDivideAndRemainder(); + + if (errors > 0) { + throw new RuntimeException(errors + " errors found in unsigned operations."); + } + } + + private static final BigInteger TWO = BigInteger.valueOf(2L); + + private static int testRoundtrip() { + int errors = 0; + + long[] data = {-1L, 0L, 1L}; + + for(long datum : data) { + if (Long.parseUnsignedLong(Long.toBinaryString(datum), 2) != datum) { + errors++; + System.err.println("Bad binary roundtrip conversion of " + datum); + } + + if (Long.parseUnsignedLong(Long.toOctalString(datum), 8) != datum) { + errors++; + System.err.println("Bad octal roundtrip conversion of " + datum); + } + + if (Long.parseUnsignedLong(Long.toHexString(datum), 16) != datum) { + errors++; + System.err.println("Bad hex roundtrip conversion of " + datum); + } + } + return errors; + } + + private static int testByteToUnsignedLong() { + int errors = 0; + + for(int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; i++) { + byte datum = (byte) i; + long ui = Byte.toUnsignedLong(datum); + + if ( (ui & (~0xffL)) != 0L || + ((byte)ui != datum )) { + errors++; + System.err.printf("Bad conversion of byte %d to unsigned long %d%n", + datum, ui); + } + } + return errors; + } + + private static int testShortToUnsignedLong() { + int errors = 0; + + for(int i = Short.MIN_VALUE; i <= Short.MAX_VALUE; i++) { + short datum = (short) i; + long ui = Short.toUnsignedLong(datum); + + if ( (ui & (~0xffffL)) != 0L || + ((short)ui != datum )) { + errors++; + System.err.printf("Bad conversion of short %d to unsigned long %d%n", + datum, ui); + } + } + return errors; + } + private static int testUnsignedCompare() { + int errors = 0; + + long[] data = { + 0L, + 1L, + 2L, + 3L, + 0x00000000_80000000L, + 0x00000000_FFFFFFFFL, + 0x00000001_00000000L, + 0x80000000_00000000L, + 0x80000000_00000001L, + 0x80000000_00000002L, + 0x80000000_00000003L, + 0x80000000_80000000L, + 0xFFFFFFFF_FFFFFFFEL, + 0xFFFFFFFF_FFFFFFFFL, + }; + + for(long i : data) { + for(long j : data) { + long libraryResult = Long.compareUnsigned(i, j); + long libraryResultRev = Long.compareUnsigned(j, i); + long localResult = compUnsigned(i, j); + + if (i == j) { + if (libraryResult != 0) { + errors++; + System.err.printf("Value 0x%x did not compare as " + + "an unsigned equal to itself; got %d%n", + i, libraryResult); + } + } + + if (Long.signum(libraryResult) != Long.signum(localResult)) { + errors++; + System.err.printf("Unsigned compare of 0x%x to 0x%x%n:" + + "\texpected sign of %d, got %d%n", + i, j, localResult, libraryResult); + } + + if (Long.signum(libraryResult) != + -Long.signum(libraryResultRev)) { + errors++; + System.err.printf("signum(compareUnsigned(x, y)) != -signum(compareUnsigned(y,x))" + + " for \t0x%x and 0x%x, computed %d and %d%n", + i, j, libraryResult, libraryResultRev); + } + } + } + + return errors; + } + + private static int compUnsigned(long x, long y) { + BigInteger big_x = toUnsignedBigInt(x); + BigInteger big_y = toUnsignedBigInt(y); + + return big_x.compareTo(big_y); + } + + private static BigInteger toUnsignedBigInt(long x) { + if (x >= 0) + return BigInteger.valueOf(x); + else { + int upper = (int)(((long)x) >> 32); + int lower = (int) x; + + BigInteger bi = // (upper << 32) + lower + (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32). + add(BigInteger.valueOf(Integer.toUnsignedLong(lower))); + + // System.out.printf("%n\t%d%n\t%s%n", x, bi.toString()); + return bi; + } + } + + private static int testToStringUnsigned() { + int errors = 0; + + long[] data = { + 0L, + 1L, + 2L, + 3L, + 99999L, + 100000L, + 999999L, + 100000L, + 999999999L, + 1000000000L, + 0x1234_5678L, + 0x8000_0000L, + 0x8000_0001L, + 0x8000_0002L, + 0x8000_0003L, + 0x8765_4321L, + 0xFFFF_FFFEL, + 0xFFFF_FFFFL, + + // Long-range values + 999_999_999_999L, + 1_000_000_000_000L, + + 999_999_999_999_999_999L, + 1_000_000_000_000_000_000L, + + 0xFFFF_FFFF_FFFF_FFFEL, + 0xFFFF_FFFF_FFFF_FFFFL, + }; + + for(int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) { + for(long datum : data) { + String result1 = Long.toUnsignedString(datum, radix); + String result2 = toUnsignedBigInt(datum).toString(radix); + + if (!result1.equals(result2)) { + errors++; + System.err.printf("Unexpected string difference converting 0x%x:" + + "\t%s %s%n", + datum, result1, result2); + } + + if (radix == 10) { + String result3 = Long.toUnsignedString(datum); + if (!result2.equals(result3)) { + errors++; + System.err.printf("Unexpected string difference converting 0x%x:" + + "\t%s %s%n", + datum, result3, result2); + } + } + + long parseResult = Long.parseUnsignedLong(result1, radix); + + if (parseResult != datum) { + errors++; + System.err.printf("Bad roundtrip conversion of %d in base %d" + + "\tconverting back ''%s'' resulted in %d%n", + datum, radix, result1, parseResult); + } + } + } + + return errors; + } + + private static int testParseUnsignedLong() { + int errors = 0; + long maxUnsignedInt = Integer.toUnsignedLong(0xffff_ffff); + + // Values include those between signed Long.MAX_VALUE and + // unsignted Long MAX_VALUE. + BigInteger[] inRange = { + BigInteger.valueOf(0L), + BigInteger.valueOf(1L), + BigInteger.valueOf(10L), + BigInteger.valueOf(2147483646L), // Integer.MAX_VALUE - 1 + BigInteger.valueOf(2147483647L), // Integer.MAX_VALUE + BigInteger.valueOf(2147483648L), // Integer.MAX_VALUE + 1 + + BigInteger.valueOf(maxUnsignedInt - 1L), + BigInteger.valueOf(maxUnsignedInt), + + BigInteger.valueOf(Long.MAX_VALUE - 1L), + BigInteger.valueOf(Long.MAX_VALUE), + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE), + + TWO.pow(64).subtract(BigInteger.ONE) + }; + + for(BigInteger value : inRange) { + for(int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) { + String bigString = value.toString(radix); + long longResult = Long.parseUnsignedLong(bigString, radix); + + if (!toUnsignedBigInt(longResult).equals(value)) { + errors++; + System.err.printf("Bad roundtrip conversion of %d in base %d" + + "\tconverting back ''%s'' resulted in %d%n", + value, radix, bigString, longResult); + } + } + } + + String[] outOfRange = { + null, + "", + "-1", + TWO.pow(64).toString(), + }; + + for(String s : outOfRange) { + try { + long result = Long.parseUnsignedLong(s); + errors++; // Should not reach here + System.err.printf("Unexpected got %d from an unsigned conversion of %s", + result, s); + } catch(NumberFormatException nfe) { + ; // Correct result + } + } + + return errors; + } + + private static int testDivideAndRemainder() { + int errors = 0; + long MAX_UNSIGNED_INT = Integer.toUnsignedLong(0xffff_ffff); + + BigInteger[] inRange = { + BigInteger.valueOf(0L), + BigInteger.valueOf(1L), + BigInteger.valueOf(10L), + BigInteger.valueOf(2147483646L), // Integer.MAX_VALUE - 1 + BigInteger.valueOf(2147483647L), // Integer.MAX_VALUE + BigInteger.valueOf(2147483648L), // Integer.MAX_VALUE + 1 + + BigInteger.valueOf(MAX_UNSIGNED_INT - 1L), + BigInteger.valueOf(MAX_UNSIGNED_INT), + + BigInteger.valueOf(Long.MAX_VALUE - 1L), + BigInteger.valueOf(Long.MAX_VALUE), + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE), + + TWO.pow(64).subtract(BigInteger.ONE) + }; + + for(BigInteger dividend : inRange) { + for(BigInteger divisor : inRange) { + long quotient; + BigInteger longQuotient; + + long remainder; + BigInteger longRemainder; + + if (divisor.equals(BigInteger.ZERO)) { + try { + quotient = Long.divideUnsigned(dividend.longValue(), divisor.longValue()); + errors++; + } catch(ArithmeticException ea) { + ; // Expected + } + + try { + remainder = Long.remainderUnsigned(dividend.longValue(), divisor.longValue()); + errors++; + } catch(ArithmeticException ea) { + ; // Expected + } + } else { + quotient = Long.divideUnsigned(dividend.longValue(), divisor.longValue()); + longQuotient = dividend.divide(divisor); + + if (quotient != longQuotient.longValue()) { + errors++; + System.err.printf("Unexpected unsigned divide result %s on %s/%s%n", + Long.toUnsignedString(quotient), + Long.toUnsignedString(dividend.longValue()), + Long.toUnsignedString(divisor.longValue())); + } + + remainder = Long.remainderUnsigned(dividend.longValue(), divisor.longValue()); + longRemainder = dividend.remainder(divisor); + + if (remainder != longRemainder.longValue()) { + errors++; + System.err.printf("Unexpected unsigned remainder result %s on %s%%%s%n", + Long.toUnsignedString(remainder), + Long.toUnsignedString(dividend.longValue()), + Long.toUnsignedString(divisor.longValue())); + } + } + } + } + + return errors; + } +}