--- a/jdk/src/java.base/share/classes/java/lang/String.java Mon Oct 26 17:19:13 2015 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/String.java Tue Oct 27 10:15:38 2015 -0700
@@ -102,6 +102,10 @@
* Unicode code points (i.e., characters), in addition to those for
* dealing with Unicode code units (i.e., {@code char} values).
*
+ * <p>Unless otherwise noted, methods for comparing Strings do not take locale
+ * into account. The {@link java.text.Collator} class provides methods for
+ * finer-grain, locale-sensitive String comparison.
+ *
* @author Lee Boynton
* @author Arthur van Hoff
* @author Martin Buchholz
@@ -971,6 +975,9 @@
* String} object that represents the same sequence of characters as this
* object.
*
+ * <p>For finer-grained String comparison, refer to
+ * {@link java.text.Collator}.
+ *
* @param anObject
* The object to compare this {@code String} against
*
@@ -1008,6 +1015,9 @@
* sequence of characters as the specified {@code StringBuffer}. This method
* synchronizes on the {@code StringBuffer}.
*
+ * <p>For finer-grained String comparison, refer to
+ * {@link java.text.Collator}.
+ *
* @param sb
* The {@code StringBuffer} to compare this {@code String} against
*
@@ -1043,6 +1053,9 @@
* {@code CharSequence} is a {@code StringBuffer} then the method
* synchronizes on it.
*
+ * <p>For finer-grained String comparison, refer to
+ * {@link java.text.Collator}.
+ *
* @param cs
* The sequence to compare this {@code String} against
*
@@ -1092,14 +1105,14 @@
* <ul>
* <li> The two characters are the same (as compared by the
* {@code ==} operator)
- * <li> Applying the method {@link
- * java.lang.Character#toUpperCase(char)} to each character
- * produces the same result
- * <li> Applying the method {@link
- * java.lang.Character#toLowerCase(char)} to each character
- * produces the same result
+ * <li> Calling {@code Character.toLowerCase(Character.toUpperCase(char))}
+ * on each character produces the same result
* </ul>
*
+ * <p>Note that this method does <em>not</em> take locale into account, and
+ * will result in unsatisfactory results for certain locales. The
+ * {@link java.text.Collator} class provides locale-sensitive comparison.
+ *
* @param anotherString
* The {@code String} to compare this {@code String} against
*
@@ -1150,6 +1163,9 @@
* this.length()-anotherString.length()
* </pre></blockquote>
*
+ * <p>For finer-grained String comparison, refer to
+ * {@link java.text.Collator}.
+ *
* @param anotherString the {@code String} to be compared.
* @return the value {@code 0} if the argument string is equal to
* this string; a value less than {@code 0} if this string
@@ -1181,10 +1197,9 @@
* <p>
* Note that this Comparator does <em>not</em> take locale into account,
* and will result in an unsatisfactory ordering for certain locales.
- * The java.text package provides <em>Collators</em> to allow
- * locale-sensitive ordering.
+ * The {@link java.text.Collator} class provides locale-sensitive comparison.
*
- * @see java.text.Collator#compare(String, String)
+ * @see java.text.Collator
* @since 1.2
*/
public static final Comparator<String> CASE_INSENSITIVE_ORDER
@@ -1231,14 +1246,13 @@
* <p>
* Note that this method does <em>not</em> take locale into account,
* and will result in an unsatisfactory ordering for certain locales.
- * The java.text package provides <em>collators</em> to allow
- * locale-sensitive ordering.
+ * The {@link java.text.Collator} class provides locale-sensitive comparison.
*
* @param str the {@code String} to be compared.
* @return a negative integer, zero, or a positive integer as the
* specified String is greater than, equal to, or less
* than this String, ignoring case considerations.
- * @see java.text.Collator#compare(String, String)
+ * @see java.text.Collator
* @since 1.2
*/
public int compareToIgnoreCase(String str) {
@@ -1268,6 +1282,9 @@
* <i>k</i>{@code )}
* </ul>
*
+ * <p>Note that this method does <em>not</em> take locale into account. The
+ * {@link java.text.Collator} class provides locale-sensitive comparison.
+ *
* @param toffset the starting offset of the subregion in this string.
* @param other the string argument.
* @param ooffset the starting offset of the subregion in the string
@@ -1323,16 +1340,16 @@
* <li>{@code ignoreCase} is {@code true} and there is some nonnegative
* integer <i>k</i> less than {@code len} such that:
* <blockquote><pre>
- * Character.toLowerCase(this.charAt(toffset+k)) !=
- Character.toLowerCase(other.charAt(ooffset+k))
- * </pre></blockquote>
- * and:
- * <blockquote><pre>
- * Character.toUpperCase(this.charAt(toffset+k)) !=
- * Character.toUpperCase(other.charAt(ooffset+k))
+ * Character.toLowerCase(Character.toUpperCase(this.charAt(toffset+k))) !=
+ Character.toLowerCase(Character.toUpperCase(other.charAt(ooffset+k)))
* </pre></blockquote>
* </ul>
*
+ * <p>Note that this method does <em>not</em> take locale into account,
+ * and will result in unsatisfactory results for certain locales when
+ * {@code ignoreCase} is {@code true}. The {@link java.text.Collator} class
+ * provides locale-sensitive comparison.
+ *
* @param ignoreCase if {@code true}, ignore case when comparing
* characters.
* @param toffset the starting offset of the subregion in this
--- a/jdk/src/java.base/share/classes/java/lang/Throwable.java Mon Oct 26 17:19:13 2015 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/Throwable.java Tue Oct 27 10:15:38 2015 -0700
@@ -211,8 +211,7 @@
// Setting this static field introduces an acceptable
// initialization dependency on a few java.util classes.
- private static final List<Throwable> SUPPRESSED_SENTINEL =
- Collections.unmodifiableList(new ArrayList<Throwable>(0));
+ private static final List<Throwable> SUPPRESSED_SENTINEL = Collections.emptyList();
/**
* The list of suppressed exceptions, as returned by {@link
--- a/jdk/src/java.base/share/classes/java/lang/invoke/BoundMethodHandle.java Mon Oct 26 17:19:13 2015 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/invoke/BoundMethodHandle.java Tue Oct 27 10:15:38 2015 -0700
@@ -404,14 +404,6 @@
d = lookupCache(types);
// Class loading must have upgraded the cache.
assert(d != null && !d.isPlaceholder());
- if (OBSERVE_BMH_SPECIES_CREATION) {
- if (d == null) {
- throw new IllegalStateException("d == null");
- }
- if (d.isPlaceholder()) {
- throw new IllegalStateException("d is place holder");
- }
- }
return d;
}
static SpeciesData getForClass(String types, Class<? extends BoundMethodHandle> clazz) {
@@ -423,9 +415,6 @@
if (d != null) return d;
d = new SpeciesData(types);
assert(d.isPlaceholder());
- if (OBSERVE_BMH_SPECIES_CREATION && !d.isPlaceholder()) {
- throw new IllegalStateException("d is not place holder");
- }
CACHE.put(types, d);
return d;
}
@@ -433,15 +422,6 @@
SpeciesData d2;
assert((d2 = CACHE.get(types)) == null || d2.isPlaceholder());
assert(!d.isPlaceholder());
- if (OBSERVE_BMH_SPECIES_CREATION) {
- d2 = CACHE.get(types);
- if (d2 != null && !d2.isPlaceholder()) {
- throw new IllegalStateException("non-null d2 is not place holder");
- }
- if (d.isPlaceholder()) {
- throw new IllegalStateException("d is place holder");
- }
- }
CACHE.put(types, d);
return d;
}
--- a/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandleStatics.java Mon Oct 26 17:19:13 2015 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandleStatics.java Tue Oct 27 10:15:38 2015 -0700
@@ -51,12 +51,8 @@
static final boolean PROFILE_GWT;
static final int CUSTOMIZE_THRESHOLD;
- // This is a temporary property added for improved error reporting; it will
- // be removed once it has served its purpose.
- static final boolean OBSERVE_BMH_SPECIES_CREATION;
-
static {
- final Object[] values = new Object[10];
+ final Object[] values = new Object[9];
AccessController.doPrivileged(new PrivilegedAction<>() {
public Void run() {
values[0] = Boolean.getBoolean("java.lang.invoke.MethodHandle.DEBUG_NAMES");
@@ -68,7 +64,6 @@
values[6] = Integer.getInteger("java.lang.invoke.MethodHandle.PROFILE_LEVEL", 0);
values[7] = Boolean.parseBoolean(System.getProperty("java.lang.invoke.MethodHandle.PROFILE_GWT", "true"));
values[8] = Integer.getInteger("java.lang.invoke.MethodHandle.CUSTOMIZE_THRESHOLD", 127);
- values[9] = Boolean.getBoolean("java.lang.invoke.MethodHandle.OBSERVE_BMH_SPECIES_CREATION");
return null;
}
});
@@ -82,8 +77,6 @@
PROFILE_GWT = (Boolean) values[7];
CUSTOMIZE_THRESHOLD = (Integer) values[8];
- OBSERVE_BMH_SPECIES_CREATION = (Boolean) values[9];
-
if (CUSTOMIZE_THRESHOLD < -1 || CUSTOMIZE_THRESHOLD > 127) {
throw newInternalError("CUSTOMIZE_THRESHOLD should be in [-1...127] range");
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/String/EqualsIgnoreCase.java Tue Oct 27 10:15:38 2015 -0700
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2015, 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 8138824
+ * @summary Test expected equalsIgnoreCase behavior for some known asymmetric case mappings
+ */
+
+public class EqualsIgnoreCase {
+ private static final String SMALL_I = "i";
+ private static final String CAPITAL_I = "I";
+ // Characters that do not map symmetrically between upper/lower case
+ private static final String SMALL_DOTLESS_I = "\u0131";
+ private static final String CAPITAL_I_WITH_DOT = "\u0130";
+ private static final String LOWER_GREEK_THETA = "\u03D1";
+ private static final String CAPITAL_GREEK_THETA = "\u03F4";
+
+ public static void main(String[] args) {
+ compareFuncs(SMALL_I, CAPITAL_I, true, true);
+ compareFuncs(CAPITAL_I_WITH_DOT, SMALL_DOTLESS_I, true, false);
+ compareFuncs(LOWER_GREEK_THETA, CAPITAL_GREEK_THETA, true, false);
+ }
+
+ /**
+ * Compare the actual results of equalsIgnoreCase():
+ * toUpperCase(toLowerCase(eachChar))
+ * to the behavior described in the equalsIgnoreCase() spec prior to 8138824:
+ * toUpperCase(eachChar)
+ * toLowerCase(eachChar)
+ *
+ * @param s1 A string
+ * @param s2 Another string
+ * @param expectEquals Expected result of equalsIgnoreCase()
+ * @param expectTuTl Expected result of toUpperToLowerOriginals()
+ */
+ private static void compareFuncs(String s1, String s2, boolean expectEquals, boolean expectTuTl) {
+ System.out.println(s1 + ", " + s2);
+ boolean equalsResult = s1.equalsIgnoreCase(s2);
+ System.out.println("equalsIgnoreCase:" + equalsResult);
+
+ boolean tuTlResult = toUpperToLowerOriginals(s1, s2);
+ System.out.println("tUtLO:" + tuTlResult);
+ boolean failed = false;
+
+ if (equalsResult != expectEquals) {
+ System.out.println("Expected " + expectEquals + " from equalsIgnoreCase() but got " + equalsResult);
+ failed = true;
+ }
+ if (tuTlResult != expectTuTl) {
+ System.out.println("Expected " + expectTuTl + " from toUpperToLowerOriginals() but got " + tuTlResult);
+ failed = true;
+ }
+ if (failed) { throw new RuntimeException("Test Failed"); }
+ }
+
+ /**
+ * Apply toUpperCase() and toLowerCase() to corresponding chars of both
+ * Strings. Returns true if each pair of corresponding chars are either:
+ * 1. == after both are converted to upper case
+ * or
+ * 2. == after both are converted to lower case
+ * and the String lengths are equal.
+ */
+ private static boolean toUpperToLowerOriginals(String str1, String str2) {
+ if (str1.length() != str2.length()) { return false; }
+ for (int i = 0; i < str1.length(); i++) {
+ char c1 = str1.charAt(i);
+ char c2 = str2.charAt(i);
+
+ char uc1 = Character.toUpperCase(c1);
+ char uc2 = Character.toUpperCase(c2);
+ boolean upperMatch = uc1 == uc2;
+
+ char lc1 = Character.toLowerCase(c1);
+ char lc2 = Character.toLowerCase(c2);
+ boolean lowerMatch = lc1 == lc2;
+
+ if (!(upperMatch || lowerMatch)) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
--- a/jdk/test/java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java Mon Oct 26 17:19:13 2015 -0700
+++ b/jdk/test/java/lang/invoke/LFCaching/LFMultiThreadCachingTest.java Tue Oct 27 10:15:38 2015 -0700
@@ -32,7 +32,7 @@
* @build LambdaFormTestCase
* @build LFCachingTestCase
* @build LFMultiThreadCachingTest
- * @run main/othervm -Djava.lang.invoke.MethodHandle.OBSERVE_BMH_SPECIES_CREATION=true LFMultiThreadCachingTest
+ * @run main/othervm LFMultiThreadCachingTest
*/
import java.lang.invoke.MethodHandle;