3789983e89
Reviewed-by: darcy, ihse
408 lines
14 KiB
Java
408 lines
14 KiB
Java
/*
|
|
* 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.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();
|
|
errors += testDivideAndRemainder();
|
|
|
|
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 final long MAX_UNSIGNED_INT = Integer.toUnsignedLong(0xffff_ffff);
|
|
|
|
private static int testParseUnsignedInt() {
|
|
int errors = 0;
|
|
|
|
// 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
|
|
|
|
MAX_UNSIGNED_INT - 1L,
|
|
MAX_UNSIGNED_INT,
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
// test offset based parse method
|
|
intResult = Integer.parseUnsignedInt("prefix" + longString + "suffix",
|
|
"prefix".length(), "prefix".length() + longString.length(), 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(MAX_UNSIGNED_INT + 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;
|
|
}
|
|
|
|
private static int testDivideAndRemainder() {
|
|
int errors = 0;
|
|
|
|
long[] inRange = {
|
|
0L,
|
|
1L,
|
|
2L,
|
|
2147483646L, // MAX_VALUE - 1
|
|
2147483647L, // MAX_VALUE
|
|
2147483648L, // MAX_VALUE + 1
|
|
|
|
MAX_UNSIGNED_INT - 1L,
|
|
MAX_UNSIGNED_INT,
|
|
};
|
|
|
|
for(long dividend : inRange) {
|
|
for(long divisor : inRange) {
|
|
int quotient;
|
|
long longQuotient;
|
|
|
|
int remainder;
|
|
long longRemainder;
|
|
|
|
if (divisor == 0) {
|
|
try {
|
|
quotient = Integer.divideUnsigned((int) dividend, (int) divisor);
|
|
errors++;
|
|
} catch(ArithmeticException ea) {
|
|
; // Expected
|
|
}
|
|
|
|
try {
|
|
remainder = Integer.remainderUnsigned((int) dividend, (int) divisor);
|
|
errors++;
|
|
} catch(ArithmeticException ea) {
|
|
; // Expected
|
|
}
|
|
} else {
|
|
quotient = Integer.divideUnsigned((int) dividend, (int) divisor);
|
|
longQuotient = dividend / divisor;
|
|
|
|
if (quotient != (int)longQuotient) {
|
|
errors++;
|
|
System.err.printf("Unexpected unsigned divide result %s on %s/%s%n",
|
|
Integer.toUnsignedString(quotient),
|
|
Integer.toUnsignedString((int) dividend),
|
|
Integer.toUnsignedString((int) divisor));
|
|
}
|
|
|
|
remainder = Integer.remainderUnsigned((int) dividend, (int) divisor);
|
|
longRemainder = dividend % divisor;
|
|
|
|
if (remainder != (int)longRemainder) {
|
|
errors++;
|
|
System.err.printf("Unexpected unsigned remainder result %s on %s%%%s%n",
|
|
Integer.toUnsignedString(remainder),
|
|
Integer.toUnsignedString((int) dividend),
|
|
Integer.toUnsignedString((int) divisor));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
}
|