stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8138824: java.lang.String: spec doesn't match impl when ignoring case - equalsIgnoreCase(), regionMatches()

Browse Source 
Reviewed-by: naoto, rriggs
This commit is contained in:
Brent Christian 2015-10-27 09:20:24 -07:00
parent 392da5db2d
commit 084b341c80
2 changed files with 140 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
jdk/src/java.base/share/classes/java/lang/String.java
View File

@ -102,6 +102,10 @@ import jdk.internal.HotSpotIntrinsicCandidate;
* 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 @@ public final class String
* 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 @@ public final class String
* 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 @@ public final class String
* {@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 @@ public final class String
* <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 @@ public final class String
* 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 @@ public final class String
* <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 @@ public final class String
* <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 @@ public final class String
* <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 @@ public final class String
* <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

104
jdk/test/java/lang/String/EqualsIgnoreCase.java Normal file
View File

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