infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-02-24 01:00:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Sean Mullan 2012-01-23 13:23:05 -05:00
commit 20acbf2a93
8 changed files with 1486 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
jdk/src/share/classes/java/lang/Byte.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 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
@ -445,6 +445,47 @@ public final class Byte extends Number implements Comparable<Byte> {
return x - y;
}
/**
* Converts the argument to an {@code int} by an unsigned
* conversion. In an unsigned conversion to an {@code int}, the
* high-order 24 bits of the {@code int} are zero and the
* low-order 8 bits are equal to the bits of the {@code byte} argument.
*
* Consequently, zero and positive {@code byte} values are mapped
* to a numerically equal {@code int} value and negative {@code
* byte} values are mapped to an {@code int} value equal to the
* input plus 2<sup>8</sup>.
*
* @param x the value to convert to an unsigned {@code int}
* @return the argument converted to {@code int} by an unsigned
* conversion
* @since 1.8
*/
public static int toUnsignedInt(byte x) {
return ((int) x) & 0xff;
}
/**
* Converts the argument to a {@code long} by an unsigned
* conversion. In an unsigned conversion to a {@code long}, the
* high-order 56 bits of the {@code long} are zero and the
* low-order 8 bits are equal to the bits of the {@code byte} argument.
*
* Consequently, zero and positive {@code byte} values are mapped
* to a numerically equal {@code long} value and negative {@code
* byte} values are mapped to a {@code long} value equal to the
* input plus 2<sup>8</sup>.
*
* @param x the value to convert to an unsigned {@code long}
* @return the argument converted to {@code long} by an unsigned
* conversion
* @since 1.8
*/
public static long toUnsignedLong(byte x) {
return ((long) x) & 0xffL;
}
/**
* The number of bits used to represent a {@code byte} value in two's
* complement binary form.

289
jdk/src/share/classes/java/lang/Integer.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1994, 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
@ -128,7 +128,6 @@ public final class Integer extends Number implements Comparable<Integer> {
* @see java.lang.Character#MIN_RADIX
*/
public static String toString(int i, int radix) {
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;
@ -158,6 +157,36 @@ public final class Integer extends Number implements Comparable<Integer> {
return new String(buf, charPos, (33 - charPos));
}
/**
* Returns a string representation of the first argument as an
* unsigned integer value in the radix specified by the second
* argument.
*
* <p>If the radix is smaller than {@code Character.MIN_RADIX}
* or larger than {@code Character.MAX_RADIX}, then the radix
* {@code 10} is used instead.
*
* <p>Note that since the first argument is treated as an unsigned
* value, no leading sign character is printed.
*
* <p>If the magnitude is zero, it is represented by a single zero
* character {@code '0'} (<code>'&#92;u0030'</code>); otherwise,
* the first character of the representation of the magnitude will
* not be the zero character.
*
* <p>The behavior of radixes and the characters used as digits
* are the same as {@link #toString(int, int) toString}.
*
* @param i an integer to be converted to an unsigned string.
* @param radix the radix to use in the string representation.
* @return an unsigned string representation of the argument in the specified radix.
* @see #toString(int, int)
* @since 1.8
*/
public static String toUnsignedString(int i, int radix) {
return Long.toString(toUnsignedLong(i), radix);
}
/**
* Returns a string representation of the integer argument as an
* unsigned integer in base&nbsp;16.
@ -166,12 +195,18 @@ public final class Integer extends Number implements Comparable<Integer> {
* if the argument is negative; otherwise, it is equal to the
* argument. This value is converted to a string of ASCII digits
* in hexadecimal (base&nbsp;16) with no extra leading
* {@code 0}s. If the unsigned magnitude is zero, it is
* represented by a single zero character {@code '0'}
* (<code>'&#92;u0030'</code>); otherwise, the first character of
* the representation of the unsigned magnitude will not be the
* zero character. The following characters are used as
* hexadecimal digits:
* {@code 0}s.
*
* <p>The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Integer#parseUnsignedInt(String, int)
* Integer.parseUnsignedInt(s, 16)}.
*
* <p>If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'} (<code>'&#92;u0030'</code>);
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* following characters are used as hexadecimal digits:
*
* <blockquote>
* {@code 0123456789abcdef}
@ -190,10 +225,12 @@ public final class Integer extends Number implements Comparable<Integer> {
* @param i an integer to be converted to a string.
* @return the string representation of the unsigned integer value
* represented by the argument in hexadecimal (base&nbsp;16).
* @see #parseUnsignedInt(String, int)
* @see #toUnsignedString(int, int)
* @since JDK1.0.2
*/
public static String toHexString(int i) {
return toUnsignedString(i, 4);
return toUnsignedString0(i, 4);
}
/**
@ -205,12 +242,16 @@ public final class Integer extends Number implements Comparable<Integer> {
* argument. This value is converted to a string of ASCII digits
* in octal (base&nbsp;8) with no extra leading {@code 0}s.
*
* <p>The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Integer#parseUnsignedInt(String, int)
* Integer.parseUnsignedInt(s, 8)}.
*
* <p>If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'}
* (<code>'&#92;u0030'</code>); otherwise, the first character of
* the representation of the unsigned magnitude will not be the
* zero character. The following characters are used as octal
* digits:
* single zero character {@code '0'} (<code>'&#92;u0030'</code>);
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* following characters are used as octal digits:
*
* <blockquote>
* {@code 01234567}
@ -222,10 +263,12 @@ public final class Integer extends Number implements Comparable<Integer> {
* @param i an integer to be converted to a string.
* @return the string representation of the unsigned integer value
* represented by the argument in octal (base&nbsp;8).
* @see #parseUnsignedInt(String, int)
* @see #toUnsignedString(int, int)
* @since JDK1.0.2
*/
public static String toOctalString(int i) {
return toUnsignedString(i, 3);
return toUnsignedString0(i, 3);
}
/**
@ -236,27 +279,34 @@ public final class Integer extends Number implements Comparable<Integer> {
* if the argument is negative; otherwise it is equal to the
* argument. This value is converted to a string of ASCII digits
* in binary (base&nbsp;2) with no extra leading {@code 0}s.
* If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'}
* (<code>'&#92;u0030'</code>); otherwise, the first character of
* the representation of the unsigned magnitude will not be the
* zero character. The characters {@code '0'}
* (<code>'&#92;u0030'</code>) and {@code '1'}
* (<code>'&#92;u0031'</code>) are used as binary digits.
*
* <p>The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Integer#parseUnsignedInt(String, int)
* Integer.parseUnsignedInt(s, 2)}.
*
* <p>If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'} (<code>'&#92;u0030'</code>);
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* characters {@code '0'} (<code>'&#92;u0030'</code>) and {@code
* '1'} (<code>'&#92;u0031'</code>) are used as binary digits.
*
* @param i an integer to be converted to a string.
* @return the string representation of the unsigned integer value
* represented by the argument in binary (base&nbsp;2).
* @see #parseUnsignedInt(String, int)
* @see #toUnsignedString(int, int)
* @since JDK1.0.2
*/
public static String toBinaryString(int i) {
return toUnsignedString(i, 1);
return toUnsignedString0(i, 1);
}
/**
* Convert the integer to an unsigned number.
*/
private static String toUnsignedString(int i, int shift) {
private static String toUnsignedString0(int i, int shift) {
char[] buf = new char[32];
int charPos = 32;
int radix = 1 << shift;
@ -334,6 +384,24 @@ public final class Integer extends Number implements Comparable<Integer> {
return new String(0, size, buf);
}
/**
* Returns a string representation of the argument as an unsigned
* decimal value.
*
* The argument is converted to unsigned decimal representation
* and returned as a string exactly as if the argument and radix
* 10 were given as arguments to the {@link #toUnsignedString(int,
* int)} method.
*
* @param i an integer to be converted to an unsigned string.
* @return an unsigned string representation of the argument.
* @see #toUnsignedString(int, int)
* @since 1.8
*/
public static String toUnsignedString(int i) {
return Long.toString(toUnsignedLong(i));
}
/**
* Places characters representing the integer i into the
* character array buf. The characters are placed into
@ -528,6 +596,102 @@ public final class Integer extends Number implements Comparable<Integer> {
return parseInt(s,10);
}
/**
* Parses the string argument as an unsigned integer in the radix
* specified by the second argument. An unsigned integer maps the
* values usually associated with negative numbers to positive
* numbers larger than {@code MAX_VALUE}.
*
* The characters in the string must all be digits of the
* specified radix (as determined by whether {@link
* java.lang.Character#digit(char, int)} returns a nonnegative
* value), except that the first character may be an ASCII plus
* sign {@code '+'} (<code>'&#92;u002B'</code>). The resulting
* integer value is returned.
*
* <p>An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
* <ul>
* <li>The first argument is {@code null} or is a string of
* length zero.
*
* <li>The radix is either smaller than
* {@link java.lang.Character#MIN_RADIX} or
* larger than {@link java.lang.Character#MAX_RADIX}.
*
* <li>Any character of the string is not a digit of the specified
* radix, except that the first character may be a plus sign
* {@code '+'} (<code>'&#92;u002B'</code>) provided that the
* string is longer than length 1.
*
* <li>The value represented by the string is larger than the
* largest unsigned {@code int}, 2<sup>32</sup>-1.
*
* </ul>
*
*
* @param s the {@code String} containing the unsigned integer
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @return the integer represented by the string argument in the
* specified radix.
* @throws NumberFormatException if the {@code String}
* does not contain a parsable {@code int}.
* @since 1.8
*/
public static int parseUnsignedInt(String s, int radix)
throws NumberFormatException {
if (s == null) {
throw new NumberFormatException("null");
}
int len = s.length();
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar == '-') {
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else {
if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
(radix == 10 && len <= 9) ) { // Integer.MAX_VALUE in base 10 is 10 digits
return parseInt(s, radix);
} else {
long ell = Long.parseLong(s, radix);
if ((ell & 0xffff_ffff_0000_0000L) == 0) {
return (int) ell;
} else {
throw new
NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned int.", s));
}
}
}
} else {
throw NumberFormatException.forInputString(s);
}
}
/**
* Parses the string argument as an unsigned decimal integer. The
* characters in the string must all be decimal digits, except
* that the first character may be an an ASCII plus sign {@code
* '+'} (<code>'&#92;u002B'</code>). The resulting integer value
* is returned, exactly as if the argument and the radix 10 were
* given as arguments to the {@link
* #parseUnsignedInt(java.lang.String, int)} method.
*
* @param s a {@code String} containing the unsigned {@code int}
* representation to be parsed
* @return the unsigned integer value represented by the argument in decimal.
* @throws NumberFormatException if the string does not contain a
* parsable unsigned integer.
* @since 1.8
*/
public static int parseUnsignedInt(String s) throws NumberFormatException {
return parseUnsignedInt(s, 10);
}
/**
* Returns an {@code Integer} object holding the value
* extracted from the specified {@code String} when parsed
@ -1030,6 +1194,83 @@ public final class Integer extends Number implements Comparable<Integer> {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
/**
* Compares two {@code int} values numerically treating the values
* as unsigned.
*
* @param x the first {@code int} to compare
* @param y the second {@code int} to compare
* @return the value {@code 0} if {@code x == y}; a value less
* than {@code 0} if {@code x < y} as unsigned values; and
* a value greater than {@code 0} if {@code x > y} as
* unsigned values
* @since 1.8
*/
public static int compareUnsigned(int x, int y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
/**
* Converts the argument to a {@code long} by an unsigned
* conversion. In an unsigned conversion to a {@code long}, the
* high-order 32 bits of the {@code long} are zero and the
* low-order 32 bits are equal to the bits of the integer
* argument.
*
* Consequently, zero and positive {@code int} values are mapped
* to a numerically equal {@code long} value and negative {@code
* int} values are mapped to a {@code long} value equal to the
* input plus 2<sup>32</sup>.
*
* @param x the value to convert to an unsigned {@code long}
* @return the argument converted to {@code long} by an unsigned
* conversion
* @since 1.8
*/
public static long toUnsignedLong(int x) {
return ((long) x) & 0xffffffffL;
}
/**
* Returns the unsigned quotient of dividing the first argument by
* the second where each argument and the result is interpreted as
* an unsigned value.
*
* <p>Note that in two's complement arithmetic, the three other
* basic arithmetic operations of add, subtract, and multiply are
* bit-wise identical if the two operands are regarded as both
* being signed or both being unsigned. Therefore separate {@code
* addUnsigned}, etc. methods are not provided.
*
* @param dividend the value to be divided
* @param divisor the value doing the dividing
* @return the unsigned quotient of the first argument divided by
* the second argument
* @see #remainderUnsigned
* @since 1.8
*/
public static int divideUnsigned(int dividend, int divisor) {
// In lieu of tricky code, for now just use long arithmetic.
return (int)(toUnsignedLong(dividend) / toUnsignedLong(divisor));
}
/**
* Returns the unsigned remainder from dividing the first argument
* by the second where each argument and the result is interpreted
* as an unsigned value.
*
* @param dividend the value to be divided
* @param divisor the value doing the dividing
* @return the unsigned remainder of the first argument divided by
* the second argument
* @see #divideUnsigned
* @since 1.8
*/
public static int remainderUnsigned(int dividend, int divisor) {
// In lieu of tricky code, for now just use long arithmetic.
return (int)(toUnsignedLong(dividend) % toUnsignedLong(divisor));
}
// Bit twiddling

364
jdk/src/share/classes/java/lang/Long.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1994, 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
@ -25,6 +25,8 @@
package java.lang;
import java.math.*;
/**
* The {@code Long} class wraps a value of the primitive type {@code
* long} in an object. An object of type {@code Long} contains a
@ -139,6 +141,88 @@ public final class Long extends Number implements Comparable<Long> {
return new String(buf, charPos, (65 - charPos));
}
/**
* Returns a string representation of the first argument as an
* unsigned integer value in the radix specified by the second
* argument.
*
* <p>If the radix is smaller than {@code Character.MIN_RADIX}
* or larger than {@code Character.MAX_RADIX}, then the radix
* {@code 10} is used instead.
*
* <p>Note that since the first argument is treated as an unsigned
* value, no leading sign character is printed.
*
* <p>If the magnitude is zero, it is represented by a single zero
* character {@code '0'} (<code>'&#92;u0030'</code>); otherwise,
* the first character of the representation of the magnitude will
* not be the zero character.
*
* <p>The behavior of radixes and the characters used as digits
* are the same as {@link #toString(long, int) toString}.
*
* @param i an integer to be converted to an unsigned string.
* @param radix the radix to use in the string representation.
* @return an unsigned string representation of the argument in the specified radix.
* @see #toString(long, int)
* @since 1.8
*/
public static String toUnsignedString(long i, int radix) {
if (i >= 0)
return toString(i, radix);
else {
switch (radix) {
case 2:
return toBinaryString(i);
case 4:
return toUnsignedString0(i, 2);
case 8:
return toOctalString(i);
case 10:
/*
* We can get the effect of an unsigned division by 10
* on a long value by first shifting right, yielding a
* positive value, and then dividing by 5. This
* allows the last digit and preceding digits to be
* isolated more quickly than by an initial conversion
* to BigInteger.
*/
long quot = (i >>> 1) / 5;
long rem = i - quot * 10;
return toString(quot) + rem;
case 16:
return toHexString(i);
case 32:
return toUnsignedString0(i, 5);
default:
return toUnsignedBigInteger(i).toString(radix);
}
}
}
/**
* Return a BigInteger equal to the unsigned value of the
* argument.
*/
private static BigInteger toUnsignedBigInteger(long i) {
if (i >= 0L)
return BigInteger.valueOf(i);
else {
int upper = (int) (i >>> 32);
int lower = (int) i;
// return (upper << 32) + lower
return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
}
}
/**
* Returns a string representation of the {@code long}
* argument as an unsigned integer in base&nbsp;16.
@ -147,12 +231,18 @@ public final class Long extends Number implements Comparable<Long> {
* 2<sup>64</sup> if the argument is negative; otherwise, it is
* equal to the argument. This value is converted to a string of
* ASCII digits in hexadecimal (base&nbsp;16) with no extra
* leading {@code 0}s. If the unsigned magnitude is zero, it
* is represented by a single zero character {@code '0'}
* (<code>'&#92;u0030'</code>); otherwise, the first character of
* the representation of the unsigned magnitude will not be the
* zero character. The following characters are used as
* hexadecimal digits:
* leading {@code 0}s.
*
* <p>The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s,
* 16)}.
*
* <p>If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'} (<code>'&#92;u0030'</code>);
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* following characters are used as hexadecimal digits:
*
* <blockquote>
* {@code 0123456789abcdef}
@ -172,10 +262,12 @@ public final class Long extends Number implements Comparable<Long> {
* @return the string representation of the unsigned {@code long}
* value represented by the argument in hexadecimal
* (base&nbsp;16).
* @see #parseUnsignedLong(String, int)
* @see #toUnsignedString(long, int)
* @since JDK 1.0.2
*/
public static String toHexString(long i) {
return toUnsignedString(i, 4);
return toUnsignedString0(i, 4);
}
/**
@ -188,12 +280,16 @@ public final class Long extends Number implements Comparable<Long> {
* ASCII digits in octal (base&nbsp;8) with no extra leading
* {@code 0}s.
*
* <p>The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s,
* 8)}.
*
* <p>If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'}
* (<code>'&#92;u0030'</code>); otherwise, the first character of
* the representation of the unsigned magnitude will not be the
* zero character. The following characters are used as octal
* digits:
* single zero character {@code '0'} (<code>'&#92;u0030'</code>);
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* following characters are used as octal digits:
*
* <blockquote>
* {@code 01234567}
@ -205,10 +301,12 @@ public final class Long extends Number implements Comparable<Long> {
* @param i a {@code long} to be converted to a string.
* @return the string representation of the unsigned {@code long}
* value represented by the argument in octal (base&nbsp;8).
* @see #parseUnsignedLong(String, int)
* @see #toUnsignedString(long, int)
* @since JDK 1.0.2
*/
public static String toOctalString(long i) {
return toUnsignedString(i, 3);
return toUnsignedString0(i, 3);
}
/**
@ -219,27 +317,35 @@ public final class Long extends Number implements Comparable<Long> {
* 2<sup>64</sup> if the argument is negative; otherwise, it is
* equal to the argument. This value is converted to a string of
* ASCII digits in binary (base&nbsp;2) with no extra leading
* {@code 0}s. If the unsigned magnitude is zero, it is
* represented by a single zero character {@code '0'}
* (<code>'&#92;u0030'</code>); otherwise, the first character of
* the representation of the unsigned magnitude will not be the
* zero character. The characters {@code '0'}
* (<code>'&#92;u0030'</code>) and {@code '1'}
* (<code>'&#92;u0031'</code>) are used as binary digits.
* {@code 0}s.
*
* <p>The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s,
* 2)}.
*
* <p>If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'} (<code>'&#92;u0030'</code>);
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* characters {@code '0'} (<code>'&#92;u0030'</code>) and {@code
* '1'} (<code>'&#92;u0031'</code>) are used as binary digits.
*
* @param i a {@code long} to be converted to a string.
* @return the string representation of the unsigned {@code long}
* value represented by the argument in binary (base&nbsp;2).
* @see #parseUnsignedLong(String, int)
* @see #toUnsignedString(long, int)
* @since JDK 1.0.2
*/
public static String toBinaryString(long i) {
return toUnsignedString(i, 1);
return toUnsignedString0(i, 1);
}
/**
* Convert the integer to an unsigned number.
*/
private static String toUnsignedString(long i, int shift) {
private static String toUnsignedString0(long i, int shift) {
char[] buf = new char[64];
int charPos = 64;
int radix = 1 << shift;
@ -270,6 +376,24 @@ public final class Long extends Number implements Comparable<Long> {
return new String(0, size, buf);
}
/**
* Returns a string representation of the argument as an unsigned
* decimal value.
*
* The argument is converted to unsigned decimal representation
* and returned as a string exactly as if the argument and radix
* 10 were given as arguments to the {@link #toUnsignedString(long,
* int)} method.
*
* @param i an integer to be converted to an unsigned string.
* @return an unsigned string representation of the argument.
* @see #toUnsignedString(long, int)
* @since 1.8
*/
public static String toUnsignedString(long i) {
return toUnsignedString(i, 10);
}
/**
* Places characters representing the integer i into the
* character array buf. The characters are placed into
@ -484,6 +608,121 @@ public final class Long extends Number implements Comparable<Long> {
return parseLong(s, 10);
}
/**
* Parses the string argument as an unsigned {@code long} in the
* radix specified by the second argument. An unsigned integer
* maps the values usually associated with negative numbers to
* positive numbers larger than {@code MAX_VALUE}.
*
* The characters in the string must all be digits of the
* specified radix (as determined by whether {@link
* java.lang.Character#digit(char, int)} returns a nonnegative
* value), except that the first character may be an ASCII plus
* sign {@code '+'} (<code>'&#92;u002B'</code>). The resulting
* integer value is returned.
*
* <p>An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
* <ul>
* <li>The first argument is {@code null} or is a string of
* length zero.
*
* <li>The radix is either smaller than
* {@link java.lang.Character#MIN_RADIX} or
* larger than {@link java.lang.Character#MAX_RADIX}.
*
* <li>Any character of the string is not a digit of the specified
* radix, except that the first character may be a plus sign
* {@code '+'} (<code>'&#92;u002B'</code>) provided that the
* string is longer than length 1.
*
* <li>The value represented by the string is larger than the
* largest unsigned {@code long}, 2<sup>64</sup>-1.
*
* </ul>
*
*
* @param s the {@code String} containing the unsigned integer
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @return the unsigned {@code long} represented by the string
* argument in the specified radix.
* @throws NumberFormatException if the {@code String}
* does not contain a parsable {@code long}.
* @since 1.8
*/
public static long parseUnsignedLong(String s, int radix)
throws NumberFormatException {
if (s == null) {
throw new NumberFormatException("null");
}
int len = s.length();
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar == '-') {
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else {
if (len <= 12 || // Long.MAX_VALUE in Character.MAX_RADIX is 13 digits
(radix == 10 && len <= 18) ) { // Long.MAX_VALUE in base 10 is 19 digits
return parseLong(s, radix);
}
// No need for range checks on len due to testing above.
long first = parseLong(s.substring(0, len - 1), radix);
int second = Character.digit(s.charAt(len - 1), radix);
if (second < 0) {
throw new NumberFormatException("Bad digit at end of " + s);
}
long result = first * radix + second;
if (compareUnsigned(result, first) < 0) {
/*
* The maximum unsigned value, (2^64)-1, takes at
* most one more digit to represent than the
* maximum signed value, (2^63)-1. Therefore,
* parsing (len - 1) digits will be appropriately
* in-range of the signed parsing. In other
* words, if parsing (len -1) digits overflows
* signed parsing, parsing len digits will
* certainly overflow unsigned parsing.
*
* The compareUnsigned check above catches
* situations where an unsigned overflow occurs
* incorporating the contribution of the final
* digit.
*/
throw new NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned long.", s));
}
return result;
}
} else {
throw NumberFormatException.forInputString(s);
}
}
/**
* Parses the string argument as an unsigned decimal {@code long}. The
* characters in the string must all be decimal digits, except
* that the first character may be an an ASCII plus sign {@code
* '+'} (<code>'&#92;u002B'</code>). The resulting integer value
* is returned, exactly as if the argument and the radix 10 were
* given as arguments to the {@link
* #parseUnsignedLong(java.lang.String, int)} method.
*
* @param s a {@code String} containing the unsigned {@code long}
* representation to be parsed
* @return the unsigned {@code long} value represented by the decimal string argument
* @throws NumberFormatException if the string does not contain a
* parsable unsigned integer.
* @since 1.8
*/
public static long parseUnsignedLong(String s) throws NumberFormatException {
return parseUnsignedLong(s, 10);
}
/**
* Returns a {@code Long} object holding the value
* extracted from the specified {@code String} when parsed
@ -977,6 +1216,85 @@ public final class Long extends Number implements Comparable<Long> {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
/**
* Compares two {@code long} values numerically treating the values
* as unsigned.
*
* @param x the first {@code long} to compare
* @param y the second {@code long} to compare
* @return the value {@code 0} if {@code x == y}; a value less
* than {@code 0} if {@code x < y} as unsigned values; and
* a value greater than {@code 0} if {@code x > y} as
* unsigned values
* @since 1.8
*/
public static int compareUnsigned(long x, long y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
/**
* Returns the unsigned quotient of dividing the first argument by
* the second where each argument and the result is interpreted as
* an unsigned value.
*
* <p>Note that in two's complement arithmetic, the three other
* basic arithmetic operations of add, subtract, and multiply are
* bit-wise identical if the two operands are regarded as both
* being signed or both being unsigned. Therefore separate {@code
* addUnsigned}, etc. methods are not provided.
*
* @param dividend the value to be divided
* @param divisor the value doing the dividing
* @return the unsigned quotient of the first argument divided by
* the second argument
* @see #remainderUnsigned
* @since 1.8
*/
public static long divideUnsigned(long dividend, long divisor) {
if (divisor < 0L) { // signed comparison
// Answer must be 0 or 1 depending on relative magnitude
// of dividend and divisor.
return (compareUnsigned(dividend, divisor)) < 0 ? 0L :1L;
}
if (dividend > 0) // Both inputs non-negative
return dividend/divisor;
else {
/*
* For simple code, leveraging BigInteger. Longer and faster
* code written directly in terms of operations on longs is
* possible; see "Hacker's Delight" for divide and remainder
* algorithms.
*/
return toUnsignedBigInteger(dividend).
divide(toUnsignedBigInteger(divisor)).longValue();
}
}
/**
* Returns the unsigned remainder from dividing the first argument
* by the second where each argument and the result is interpreted
* as an unsigned value.
*
* @param dividend the value to be divided
* @param divisor the value doing the dividing
* @return the unsigned remainder of the first argument divided by
* the second argument
* @see #divideUnsigned
* @since 1.8
*/
public static long remainderUnsigned(long dividend, long divisor) {
if (dividend > 0 && divisor > 0) { // signed comparisons
return dividend % divisor;
} else {
if (compareUnsigned(dividend, divisor) < 0) // Avoid explicit check for 0 divisor
return dividend;
else
return toUnsignedBigInteger(dividend).
remainder(toUnsignedBigInteger(divisor)).longValue();
}
}
// Bit Twiddling

43
jdk/src/share/classes/java/lang/Short.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 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
@ -469,6 +469,47 @@ public final class Short extends Number implements Comparable<Short> {
return (short) (((i & 0xFF00) >> 8) | (i << 8));
}
/**
* Converts the argument to an {@code int} by an unsigned
* conversion. In an unsigned conversion to an {@code int}, the
* high-order 16 bits of the {@code int} are zero and the
* low-order 16 bits are equal to the bits of the {@code short} argument.
*
* Consequently, zero and positive {@code short} values are mapped
* to a numerically equal {@code int} value and negative {@code
* short} values are mapped to an {@code int} value equal to the
* input plus 2<sup>16</sup>.
*
* @param x the value to convert to an unsigned {@code int}
* @return the argument converted to {@code int} by an unsigned
* conversion
* @since 1.8
*/
public static int toUnsignedInt(short x) {
return ((int) x) & 0xffff;
}
/**
* Converts the argument to a {@code long} by an unsigned
* conversion. In an unsigned conversion to a {@code long}, the
* high-order 48 bits of the {@code long} are zero and the
* low-order 16 bits are equal to the bits of the {@code short} argument.
*
* Consequently, zero and positive {@code short} values are mapped
* to a numerically equal {@code long} value and negative {@code
* short} values are mapped to a {@code long} value equal to the
* input plus 2<sup>16</sup>.
*
* @param x the value to convert to an unsigned {@code long}
* @return the argument converted to {@code long} by an unsigned
* conversion
* @since 1.8
*/
public static long toUnsignedLong(short x) {
return ((long) x) & 0xffffL;
}
/** use serialVersionUID from JDK 1.1. for interoperability */
private static final long serialVersionUID = 7515723908773894738L;
}

13
jdk/src/share/classes/javax/crypto/Cipher.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 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
@ -26,6 +26,8 @@
package javax.crypto;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.*;
@ -389,16 +391,15 @@ public class Cipher {
return matches(regexp, value) ? S_YES : S_NO;
}
// Map<String,Pattern> for previously compiled patterns
// XXX use ConcurrentHashMap once available
private final static Map<String, Pattern> patternCache =
Collections.synchronizedMap(new HashMap<String, Pattern>());
// ConcurrentMap<String,Pattern> for previously compiled patterns
private final static ConcurrentMap<String, Pattern> patternCache =
new ConcurrentHashMap<String, Pattern>();
private static boolean matches(String regexp, String str) {
Pattern pattern = patternCache.get(regexp);
if (pattern == null) {
pattern = Pattern.compile(regexp);
patternCache.put(regexp, pattern);
patternCache.putIfAbsent(regexp, pattern);
}
return pattern.matcher(str.toUpperCase(Locale.ENGLISH)).matches();
}

396
jdk/test/java/lang/Integer/Unsigned.java Normal file
View File

@ -0,0 +1,396 @@
/*
* 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();
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);
}
}
}
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;
}
}

388
jdk/test/java/lang/Long/Unsigned.java Normal file
View File

@ -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;
}
}

5
jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/CookieHttpsClientTest.java
View File

@ -26,6 +26,11 @@
* @bug 7129083
* @summary Cookiemanager does not store cookies if url is read
* before setting cookiemanager
*
* SunJSSE does not support dynamic system properties, no way to re-use
* system properties in samevm/agentvm mode.
*
* @run main/othervm CookieHttpsClientTest
*/
import java.net.CookieHandler;