--- /dev/null 2012-01-10 11:47:00.807870926 -0800 +++ new/test/java/lang/Integer/Unsigned.java 2012-01-13 19:51:16.000000000 -0800 @@ -0,0 +1,328 @@ +/* + * 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 + */ +public class Unsigned { + public static void main(String... args) { + int errors = 0; + + errors += testRoundtrip(); + errors += testByteToUnsignedInt(); + errors += testShortToUnsignedInt(); + errors += testUnsignedCompare(); + errors += testToUnsignedLong(); + errors += testToStringUnsigned(); + errors += testParseUnsignedInt(); + + if (errors > 0) { + throw new RuntimeException(errors + " errors found in unsigned operations."); + } + } + + private static int testRoundtrip() { + int errors = 0; + + int[] data = {-1, 0, 1}; + + for(int datum : data) { + if (Integer.parseUnsignedInt(Integer.toBinaryString(datum), 2) != datum) { + errors++; + System.err.println("Bad binary roundtrip conversion of " + datum); + } + + if (Integer.parseUnsignedInt(Integer.toOctalString(datum), 8) != datum) { + errors++; + System.err.println("Bad octal roundtrip conversion of " + datum); + } + + if (Integer.parseUnsignedInt(Integer.toHexString(datum), 16) != datum) { + errors++; + System.err.println("Bad hex roundtrip conversion of " + datum); + } + } + return errors; + } + + private static int testByteToUnsignedInt() { + int errors = 0; + + for(int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; i++) { + byte datum = (byte) i; + int ui = Byte.toUnsignedInt(datum); + + if ( (ui & (~0xff)) != 0 || + ((byte)ui != datum )) { + errors++; + System.err.printf("Bad conversion of byte %d to unsigned int %d%n", + datum, ui); + } + } + return errors; + } + + private static int testShortToUnsignedInt() { + int errors = 0; + + for(int i = Short.MIN_VALUE; i <= Short.MAX_VALUE; i++) { + short datum = (short) i; + int ui = Short.toUnsignedInt(datum); + + if ( (ui & (~0xffff)) != 0 || + ((short)ui != datum )) { + errors++; + System.err.printf("Bad conversion of short %d to unsigned int %d%n", + datum, ui); + } + } + return errors; + } + + private static int testUnsignedCompare() { + int errors = 0; + + int[] data = { + 0, + 1, + 2, + 3, + 0x8000_0000, + 0x8000_0001, + 0x8000_0002, + 0x8000_0003, + 0xFFFF_FFFE, + 0xFFFF_FFFF, + }; + + for(int i : data) { + for(int j : data) { + int libraryResult = Integer.compareUnsigned(i, j); + int libraryResultRev = Integer.compareUnsigned(j, i); + int localResult = compUnsigned(i, j); + + if (i == j) { + if (libraryResult != 0) { + errors++; + System.err.printf("Value 0x%x did not compare as " + + "an unsigned value equal to itself; got %d%n", + i, libraryResult); + } + } + + if (Integer.signum(libraryResult) != Integer.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 (Integer.signum(libraryResult) != + -Integer.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; + } + + /** + * Straightforward compare unsigned algorithm. + */ + private static int compUnsigned(int x, int y) { + int sign_x = x & Integer.MIN_VALUE; + int sign_y = y & Integer.MIN_VALUE; + + int mant_x = x & (~Integer.MIN_VALUE); + int mant_y = y & (~Integer.MIN_VALUE); + + if (sign_x == sign_y) + return Integer.compare(mant_x, mant_y); + else { + if (sign_x == 0) + return -1; // sign x is 0, sign y is 1 => (x < y) + else + return 1; // sign x is 1, sign y is 0 => (x > y) + } + } + + private static int testToUnsignedLong() { + int errors = 0; + + int[] data = { + 0, + 1, + 2, + 3, + 0x1234_5678, + 0x8000_0000, + 0x8000_0001, + 0x8000_0002, + 0x8000_0003, + 0x8765_4321, + 0xFFFF_FFFE, + 0xFFFF_FFFF, + }; + + for(int datum : data) { + long result = Integer.toUnsignedLong(datum); + + // High-order bits should be zero + if ((result & 0xffff_ffff_0000_0000L) != 0L) { + errors++; + System.err.printf("High bits set converting 0x%x to 0x%x%n", + datum, result); + } + + // Lower-order bits should be equal to datum. + int lowOrder = (int)(result & 0x0000_0000_ffff_ffffL); + if (lowOrder != datum ) { + errors++; + System.err.printf("Low bits not preserved converting 0x%x to 0x%x%n", + datum, result); + } + } + return errors; + } + + private static int testToStringUnsigned() { + int errors = 0; + + int[] data = { + 0, + 1, + 2, + 3, + 99999, + 100000, + 999999, + 100000, + 999999999, + 1000000000, + 0x1234_5678, + 0x8000_0000, + 0x8000_0001, + 0x8000_0002, + 0x8000_0003, + 0x8765_4321, + 0xFFFF_FFFE, + 0xFFFF_FFFF, + }; + + for(int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) { + for(int datum : data) { + String result1 = Integer.toUnsignedString(datum, radix); + String result2 = Long.toString(Integer.toUnsignedLong(datum), 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 = Integer.toUnsignedString(datum); + if (!result2.equals(result3)) { + errors++; + System.err.printf("Unexpected string difference converting 0x%x:" + + "\t%s %s%n", + datum, result3, result2); + } + } + + int parseResult = Integer.parseUnsignedInt(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 testParseUnsignedInt() { + int errors = 0; + long maxUnsignedInt = Integer.toUnsignedLong(0xffff_ffff); + + // Values include those between signed Integer.MAX_VALUE and + // unsignted int MAX_VALUE. + long[] inRange = { + 0L, + 1L, + 10L, + 2147483646L, // MAX_VALUE - 1 + 2147483647L, // MAX_VALUE + 2147483648L, // MAX_VALUE + 1 + + maxUnsignedInt - 1L, + maxUnsignedInt, + }; + + for(long value : inRange) { + for(int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) { + String longString = Long.toString(value, radix); + int intResult = Integer.parseUnsignedInt(longString, radix); + + if (Integer.toUnsignedLong(intResult) != value) { + errors++; + System.err.printf("Bad roundtrip conversion of %d in base %d" + + "\tconverting back ''%s'' resulted in %d%n", + value, radix, longString, intResult); + } + } + } + + String[] outOfRange = { + null, + "", + "-1", + Long.toString(maxUnsignedInt + 1L), + Long.toString(Long.MAX_VALUE) + }; + + for(String s : outOfRange) { + try { + int result = Integer.parseUnsignedInt(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; + } +}