March 2021 - core-libs-dev

Insufficiencies in JEP: 400: UTF-8 by Default
by Marco 31 Mar '21

31 Mar '21

Hi all, the JEP generally paints the picture that using the OS charset would be incorrect or useless, it is however the right and perfectly valid choice for communicating with other local programs where no other charset was specified. It is the same as UTF-8 most of the time, but not always and especially not on Windows, using UTF-8 every time would be strictly less correct. Per [1] LC_CTYPE defines the charset to use for transforming between binary data and text. Given that the file.encoding system property doesn't exist within Java SE, LC_CTYPE combined with the current specification of Charset.defaultCharset() is the only compliant way to change the default charset in Java SE outside some custom application specific handling. Ignoring LC_CTYPE obviously leaves no standard approach. From the program's POV the same applies in reverse, currently one could only use Charset.defaultCharset() to determine the OS charset or let the java.io methods infer it through the charset-less constructors, then potentially read it back through e.g. InputStreamReader.getEncoding(). The OS charset is still relevant for text interaction on System.in/out/err, sub-process stdin/stdout/stderr and files with unknown encoding. Programs like grep assume the files are encoded according to LC_CTYPE, much like a similarly designed Java program that uses the OS charset on purpose. Constructing a Reader for stdin properly requires some way to determine the relevant OS encoding. I'm perfectly happy with changing the charset-less methods to use UTF-8 since it's the best choice outside the above scenarios, despite the compatibility impact. Dropping standardized support for the OS charset however not only breaks the above interactions, but also leaves no nice migration path. The - Dfile.encoding=COMPAT workaround is explicitly not standardized and isn't available to the Java application itself, only to whoever starts the JVM to presumably work around outdated code. IMO Charset should provide standardized getters for the OS charset and the console charset. The latter being different has been a long standing issue on Windows where the codepage differs between its CLI and regular environments. OpenJDK has the necessary data already available in its custom system properties. The console charset is currently hidden behind PrintStream not exposing the underlying OSWriter and not offering getEncoding() itself. The OS charset would be hidden in the future by Charset.getDefaultCharset()'s specification change in JEP 400. Please consider the above minor additions to fix those issues for good. Best regards, Marco [1] https://pubs.opengroup.org/onlinepubs/7908799/xbd/envvar.html

4 3

RFR: 8264489: Add more logging to LargeCopyWithMark.java
by Stefan Karlsson 31 Mar '21

31 Mar '21

Add more logging to the LargeCopyWithMark.java test, to gather more information when this test fails with OOME. The intention is to gather more info for JDK-8239089. I consider this patch trivial, and expect to push it after I've gotten on Review. ------------- Commit messages: - 8264489: Add more logging to LargeCopyWithMark.java Changes: https://git.openjdk.java.net/jdk/pull/3282/files Webrev: https://webrevs.openjdk.java.net/?repo=jdk&pr=3282&range=00 Issue: https://bugs.openjdk.java.net/browse/JDK-8264489 Stats: 1 line in 1 file changed: 0 ins; 0 del; 1 mod Patch: https://git.openjdk.java.net/jdk/pull/3282.diff Fetch: git fetch https://git.openjdk.java.net/jdk pull/3282/head:pull/3282 PR: https://git.openjdk.java.net/jdk/pull/3282

4 9

Re: Proposal for Decimal64 and Decimal128 value-based classes
by Douglas Surber 31 Mar '21

31 Mar '21

+1 JDBC would support this immediately. All it would take is the addition of a couple of lines in some appendices to require that conforming implementations of getObject(int, Class), setObject(int, Object, SQLType), etc support Decimal64 and Decimal128. No change to the API required. Driver vendors could add this support the instant the types are available, no need to wait for a change in the JDBC spec. This would be a huge win for many Java apps. A large fraction of Java apps deal with money in some form. Binary floats are inappropriate for money and BigDecimal is too big and too slow. Rather than waiting on Valhala I would prefer that this project be fast tracked and added to OpenJDK ASAP. Thanks for doing this. Douglas On Mar 30, 2021, at 10:10 PM, core-libs-dev-request(a)openjdk.java.net<mailto:core-libs-dev-request@openjdk.java.net> wrote: Date: Tue, 30 Mar 2021 22:12:32 -0400 From: Brian Goetz <brian.goetz(a)oracle.com<mailto:brian.goetz@oracle.com>> To: Raffaello Giulietti <raffaello.giulietti(a)gmail.com<mailto:raffaello.giulietti@gmail.com>>, Paul Sandoz <paul.sandoz(a)oracle.com<mailto:paul.sandoz@oracle.com>> Cc: core-libs-dev <core-libs-dev(a)openjdk.java.net<mailto:core-libs-dev@openjdk.java.net>> Subject: Re: Proposal for Decimal64 and Decimal128 value-based classes Message-ID: <64334a24-0e4c-57b8-b666-447ca3508ce5(a)oracle.com<mailto:64334a24-0e4c-57b8-b666-447ca3508ce5@oracle.com>> Content-Type: text/plain; charset=utf-8; format=flowed They'll find a natural home in JDBC, since SQL has a native decimal type. On 3/30/2021 7:05 PM, Raffaello Giulietti wrote: As far as I can tell, scientific computation will make use of binary floating point numbers for a long time. Decimal floating point numbers are still limited to biz and fin applications.

3 3

Further review of java.util.HexFormat
by Raffaello Giulietti 31 Mar '21

31 Mar '21

Hello Roger, these are the changes I'm proposing after reviewing the code of j.u.HexFormat. The modified code available here https://github.com/rgiulietti/jdk/commit/6759a25eb952ab19a045a83349d41b82cc… In addition to other smaller, hopefully self-explanatory enhancements, here are the rationales for the changes. Static field DIGITS should preferably be formatted with 16 values/line to ease a visual positional crosscheck with published ASCII/IsoLatin1 tables. Field digits is initialized with either UPPERCASE_DIGITS, LOWERCASE_DIGITS or digits from another instance, so it always ends up being either UPPERCASE_DIGITS or LOWERCASE_DIGITS. Consequently: * There's no need for requireNonNull() check in the (sole) private constructor. * It's preferable to move the last comparison in method equals() as the first factor in the return statement, so it can return faster in case of a lower/upper mismatch. (Arrays.equals() first checks for ==, so it always returns fast as used in this class. It could even be replaced by a simple == ) Method fromHexDigits(CharSequence, int) either returns a value in the range [0x00..0xff] or throws. Therefore, there's no need for the checks leading to the throwing of IllegalArgumentException in methods * parseHex(CharSequence, int, int) * parseNoDelimiter(CharSequence) which can be simplified as a consequence. The test for IllegalArgumentException in method parseHex(CharSequence, int, int), namely string.length() < valueChars || (string.length() - valueChars) % stride != 0 can be simplified as (string.length() - valueChars) % stride != 0 Indeed, at this point in the control flow we have string.length() > 0 and stride >= valueChars Assuming string.length() < valueChars as in the left operand of || we then have -stride <= -valueChars < string.length() - valueChars < 0 so string.length() - valueChars) % stride != 0 which is the right operand of ||. In other words, the left operand always implies the right one, adding nothing to it. There's no need to check again for non-nullness in private method fromHexDigits(CharSequence, int). It is invoked from two places where the check is already performed. Both fromHexDigits(CharSequence) and fromHexDigitsToLong(CharSequence) can simply invoke their 3 args counterparts. If you prefer, I can prepare a PR once there's an issue in the bug system to associate the PR with. Greetings Raffaello

2 1

RFR: 8264397: Use the blessed modifier order in jdk.incubator.foreign
by Alex Blewitt 31 Mar '21

31 Mar '21

8264397: Use the blessed modifier order in jdk.incubator.foreign ------------- Commit messages: - 8264397: Use the blessed modifier order in jdk.incubator.foreign Changes: https://git.openjdk.java.net/jdk/pull/3253/files Webrev: https://webrevs.openjdk.java.net/?repo=jdk&pr=3253&range=00 Issue: https://bugs.openjdk.java.net/browse/JDK-8264397 Stats: 16 lines in 8 files changed: 0 ins; 0 del; 16 mod Patch: https://git.openjdk.java.net/jdk/pull/3253.diff Fetch: git fetch https://git.openjdk.java.net/jdk pull/3253/head:pull/3253 PR: https://git.openjdk.java.net/jdk/pull/3253

3 6

Proposal for Decimal64 and Decimal128 value-based classes
by Raffaello Giulietti 31 Mar '21

31 Mar '21

Hello, I'm experimenting with an implementation of Decimal64 and Decimal128, two standard IEEE 754-2019 formats supporting, well, decimal floating point numbers of up to 16 resp 34 decimal digits. While BigDecimal can simulate most finite number computations on these formats by passing MathContext.DECIMAL64 and MathContext.DECIMAL128, resp., to the arithmetic operations, this approach has some shortcomings wrt to the standard: * Like the binary formats (float and double in Java), the standard mandates signed zeroes, signed infinities and NaNs for the decimal formats as well, while BigDecimal has neither. * BigDecimal is not a final class, so is not (and can never be) value-based. * BigDecimal needs support from BigInteger (another non final, non value-based class). On the other hand, classes Decimal64 and Decimal128: * Are value-based and can be declared to be primitive in a future version of OpenJDK, once Valhalla is completed. * Require 12 and 20 bytes, resp, of storage in the Valhalla model of primitive objects and have no references to other identity or primitive objects. * Support the signed zeroes, the infinities and the NaNs. * Currently support the 4 fundamental operations (+ - * /) according to the standard and will support remainder, square root, comparisons, etc. and the conversions listed in the standard. * Could be extended to support the (rather cumbersome) exceptions handling of the standard. * There's no plan to support transcendental functions, as the aim is to have numerical classes for business applications, not scientific or engineering purposes. * Are faster than the (incomplete) simulation with BigDecimal, 1x-5x in the current incarnations. I would be glad to contribute the code to the OpenJDK provided there is a genuine interest from the community and a reviewer willing to sponsor my effort. (I guess the best candidate for this role would be Joe Darcy from what I can read in this mailing list.) Greetings Raffaello

7 13

Re: RFR: 8264109: Add vectorized implementation for VectorMask.andNot()
by Xiaohong Gong 31 Mar '21

31 Mar '21

On Fri, 26 Mar 2021 01:50:33 GMT, Xiaohong Gong <xgong(a)openjdk.org> wrote: > Currently "VectorMask.andNot()" is not vectorized: > public VectorMask<E> andNot(VectorMask<E> m) { > // FIXME: Generate good code here. > return bOp(m, (i, a, b) -> a && !b); > } > This can be implemented with` "and(m.not())" `directly. Since `"VectorMask.and()/not()" `have been vectorized in hotspot, `"andNot"` > can be vectorized as well by calling them. > > The performance gain is >100% for such a simple JMH: > @Benchmark > public Object andNot(Blackhole bh) { > boolean[] mask = fm.apply(SPECIES.length()); > boolean[] r = fmt.apply(SPECIES.length()); > VectorMask<Byte> rm = VectorMask.fromArray(SPECIES, r, 0); > > for (int ic = 0; ic < INVOC_COUNT; ic++) { > for (int i = 0; i < mask.length; i += SPECIES.length()) { > VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, i); > rm = rm.andNot(vmask); > } > } > return rm; > } Hi there, could anyone please take a look at this PR? Thanks so much! ------------- PR: https://git.openjdk.java.net/jdk/pull/3211

1 0

Proposed: StringUTF16 bug fix with optimization - Part 2 of 2, Unit Tests
by Chris Johnson 30 Mar '21

30 Mar '21

This is a patch for test class "CompareIC", providing 100% unit test coverage of the fixed "java.lang.StringUTF16" methods "compareToCI" and "regionMatchesCI" in part 1 of this proposed contribution. The tests also provide 100% coverage of the current implementations of those methods, and, if run against them, will reveal the pair of small bugs detailed in part 1. These tests fill a JDK test coverage gap that allowed the lack of support for case-insensitive comparison and equality testing of strings containing case-sensitive Supplementary Multilingual Plane code-points to (apparently) go unnoticed officially until last year. As such, these tests are of value to the JDK even if my proposed revisions of "compareToCI" and "regionMatchesCI" are unacceptable. Thanks again for your consideration, ----Chris Chris W. Johnson chriswjohnson.jdk(a)gmail.com http://www.panojohnson.com/ Index: test/jdk/java/lang/String/CompareIC.java IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>US-ASCII =================================================================== diff --git a/test/jdk/java/lang/String/CompareIC.java b/test/jdk/java/lang/String/CompareIC.java --- a/test/jdk/java/lang/String/CompareIC.java (revision 60819:ee1d592a9f5389725a0338a4b5dfcf4fc3fcf20c) +++ b/test/jdk/java/lang/String/CompareIC.java (revision 60819+:ee1d592a9f53+) @@ -24,41 +24,1544 @@ /* * @test * @bug 4124769 8160312 - * @summary Test ignore-case comparison - * + * @summary Test case-insensitive comparison and equality + * @run testng/othervm -XX:+CompactStrings CompareIC + * @run testng/othervm -XX:-CompactStrings CompareIC */ -import java.net.*; -import java.io.InputStream; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.fail; + +import org.testng.annotations.Test; + import java.io.IOException; +import java.io.UncheckedIOException; +import java.util.Arrays; +import java.util.Formatter; +import java.util.function.BiFunction; +import java.util.function.IntFunction; +import java.util.function.Predicate; + +/** + * {@code CompareIC} provides generalized unit tests of {@link String} methods {@link String#equalsIgnoreCase + * equalsIgnoreCase} and {@link String#compareToIgnoreCase compareToIgnoreCase} with an emphasis on exercising + * underlying methods {@code java.lang.StringUTF16#compareToCI} and {@code java.lang.StringUTF16#regionMatchesCI}. + * It also: + * + * <ul> + * <li>Tests every case-sensitive Unicode code-point for equality to each of its case variants, using + * both {@link #equalsIgnoreCase} and {@link #compareToIgnoreCase}. + * </li> + * <li>Provides 100% test coverage of the CWJ implementations of {@code StringUTF16} methods {@code + * compareToCI}, {@code regionMatchesCI} and {@code compareCodePointsIgnoringCase}. + * </li> + * <li>Tests all premises underlying the CWJ implementations of {@code StringUTF16} methods {@code + * compareToCI}, {@code regionMatchesCI} and {@code compareCodePointsIgnoringCase}. + * </li> + * <li>Converts to separate TestNG unit tests the legacy test code from the 2016-06-27 commit. (Those + * tests provide no additional coverage, so they are preserved only for completeness.) + * </li> + * </ul> + * All tests operate by invoking local instance methods {@link #equalsIgnoreCase} and {@link #compareToIgnoreCase}, + * which may be overridden to apply these tests to any class supplying equivalent functionality. This has been + * useful, for example, while developing and benchmarking optimized implementations of {@code StringUTF16} methods + * {@code regionMatchesCI} and {@code compareToCI} outside the JDK code base. If doing so, be aware of other + * methods intended to be overridden: + * + * General + * <ul> + * <li>{@link #getTestedClassFQN()}</li> + * </ul> + * EqualsIgnoreCase + * <ul> + * <li>{@link #getEqualsIgnoreCaseMethodName()}</li> + * <li>{@link #getEqualsIgnoreCaseFormatterString()}</li> + * </ul> + * CompareToIgnoreCase + * <ul> + * <li>{@link #getCompareToIgnoreCaseMethodName()}</li> + * <li>{@link #getCompareToIgnoreCaseFormatterString()}</li> + * </ul> + * The tests will function whether or not those methods are overridden, + * but overriding them improves error message readability. + * + */ +@SuppressWarnings({ "UseOfSystemOutOrSystemErr", "DuplicateStringLiteralInspection" }) public class CompareIC { - - public static void main(String[] args) throws Exception { - String test1 = "Tess"; - String test2 = "Test"; - String test3 = "Tesu"; - CompareIC comparer = new CompareIC(); - - comparer.testTriplet(test1, test2, test3); + + /** + * Gets tested class's fully qualified name (FQN) for use in messages generated by these tests. + * + * By default, returns "java.lang.String". Intended to be overridden when this class is used + * outside the JDK-proper while, for example, developing and benchmarking optimized implementations + * of methods "{@code regionMatchesCI}" and "{@code compareToCI}" from "java.lang.StringUTF16". + * + * + * @return fully qualified name of tested class + * + * @see #getEqualsIgnoreCaseMethodName() + * @see #getCompareToIgnoreCaseMethodName() + */ + public String getTestedClassFQN() { + return String.class.getName(); + } + + /** + * Gets name of case-insensitive equality method being tested. + * + * @return case-insensitive equality method's name, for example {@code "equalsIgnoreCase"} + * + * @see #getEqualsIgnoreCaseFormatterString() + */ + public String getEqualsIgnoreCaseMethodName() { + return "equalsIgnoreCase"; + } + + /** + * Gets format string suitable for use by {@link Formatter#format(String, Object...)} to create a text + * representation of an "equalsIgnoreCase" (or equivalent) invocation. When this format is used, the {@code + * format} method is passed the following parameters: + * + * <ol> + * <li>{@code String} - First compared {@code String}, converted to string literal format.</li> + * <li>{@code int} - {@code char} offset, into first compared {@code String}, at which comparison was to begin.</li> + * <li>{@code int} - Number of {@code char}s used, starting at offset above, from first compared {@code String}.</li> + * <li>{@code String} - Second compared {@code String}, converted to string literal format.</li> + * <li>{@code int} - {@code char} offset, into second compared {@code String}, at which comparison was to begin.</li> + * <li>{@code int} - Number of {@code char}s used, starting at offset above, from second compared {@code String}.</li> + * </ol> + * For an invocation of {@link String#equalsIgnoreCase(String)}, the format string would be {@code "%s.equalsIgnoreCase(%4$)"}. + * Most of the {@code format} parameters are irrelevant in most cases (and parameter 3 makes redundant parameter 6 in almost + * any case), but these parameters should allow representation of almost any method invocation. + * + * + * @return {@link Formatter} format string used to create a text representation of an "equalsIgnoreCase" (or equivalent) + * invocation, including all of its parameters + * + * @see #getEqualsIgnoreCaseMethodName() + */ + public String getEqualsIgnoreCaseFormatterString() { + return "%1$s." + getEqualsIgnoreCaseMethodName() + "(%4$s)"; + } + + /** + * Gets name of case-insensitive comparison method being tested. + * + * @return case-insensitive comparison method's name, for example {@code "compareToIgnoreCase"} + * + * @see #getCompareToIgnoreCaseFormatterString() + */ + public String getCompareToIgnoreCaseMethodName() { + return "compareToIgnoreCase"; + } + + /** + * Gets format string suitable for use by {@link Formatter#format(String, Object...)} to create a text + * representation of a "compareToIgnoreCase" (or equivalent) invocation. When this format is used, the {@code + * format} method is passed the following parameters: + * + * <ol> + * <li>{@code String} - First compared {@code String}, converted to string literal format.</li> + * <li>{@code int} - {@code char} offset, into first compared {@code String}, at which comparison was to begin.</li> + * <li>{@code int} - Number of {@code char}s used, starting at offset above, from first compared {@code String}.</li> + * <li>{@code String} - Second compared {@code String}, converted to string literal format.</li> + * <li>{@code int} - {@code char} offset, into second compared {@code String}, at which comparison was to begin.</li> + * <li>{@code int} - Number of {@code char}s used, starting at offset above, from second compared {@code String}.</li> + * </ol> + * For an invocation of {@link String#compareToIgnoreCase(String)}, the format string would be {@code "%s.compareToIgnoreCase(%4$)"}. + * Most of the {@code format} parameters are irrelevant in most cases (and parameter 3 makes redundant parameter 6 in almost + * any case), but these parameters should allow representation of almost any method invocation. + * + * + * @return {@link Formatter} format string used to create a text representation of a "compareToIgnoreCase" (or equivalent) + * invocation, including all of its parameters + * + * @see #getCompareToIgnoreCaseMethodName() + */ + public String getCompareToIgnoreCaseFormatterString() { + return "%1$s." + getCompareToIgnoreCaseMethodName() + "(%4$s)"; + } + + /** + * Evaluates case-insensitive equality of two strings. + * + * By default, uses parameters "{@code a}" and "{@code b}" in invocation "{@code a.equalsIgnoreCase(b)}". + * Intended to be overridden when this class is used outside the JDK-proper while, for example, developing + * and benchmarking optimized implementations of "{@code java.lang.StringUTF16.regionMatchesCI}". + * + * + * @param a one string to test + * @param b the other string to test + * + * @return {@code true} if the strings were equal (exactly or case-insensitively), {@code false} otherwise + * + * @see #getEqualsIgnoreCaseMethodName() + * @see #getTestedClassFQN() + */ + public boolean equalsIgnoreCase + ( + final String a, + final String b + ){ + return a.equalsIgnoreCase(b); + } + + /** + * Compares two strings case-insensitively. + * + * By default, uses parameters "{@code a}" and "{@code b}" in invocation "{@code a.compareToIgnoreCase(b)}". + * Intended to be overridden when this class is used outside the JDK-proper while, for example, developing and + * benchmarking optimized implementations of "{@code java.lang.StringUTF16.compareToCI}". + * + * + * @param a basis of the comparison, as if invoking {@code a.compareToIgnoreCase(b)} + * @param b {@code String} to which {@code a} is compared + * + * @return negative value when {@code a < b}, zero when {@code a} equals {@code b}, + * or positive value when {@code a > b} + * + * @see #getCompareToIgnoreCaseMethodName() + * @see #getTestedClassFQN() + */ + public int compareToIgnoreCase + ( + final String a, + final String b + ){ + return a.compareToIgnoreCase(b); + } + + /** + * Legacy test for <a href=" https://bugs.java.com/bugdatabase/view_bug.do?bug_id=8160312">bug 8160312</a>. + */ + @Test + public void compareToIgnoreCase_MicroSignGreaterThanX() { + + // Code-point U+00B5 is the "MICRO SIGN" character from Unicode's ISO-8859-1 range. + // Code-point U+0058 is the "LATIN CAPITAL LETTER X" character from Unicode's US-ASCII range. + + if (compareToIgnoreCase("\u00b5", "X") <= 0) + fail("Comparison failure 1 for bug 8160312."); + } + + /** + * Legacy test for <a href=" https://bugs.java.com/bugdatabase/view_bug.do?bug_id=4124769">bug 4124769</a>. + */ + @SuppressWarnings("StringToUpperCaseOrToLowerCaseWithoutLocale") + @Test + public void compareToIgnoreCase_Triplets() { + final String test1 = "Tess"; + String test2 = "Test"; + final String test3 = "Tesu"; + + testTriplet(test1, test2, test3); test2 = test2.toUpperCase(); - comparer.testTriplet(test1, test2, test3); + testTriplet(test1, test2, test3); test2 = test2.toLowerCase(); - comparer.testTriplet(test1, test2, test3); - - // toLowerCase -> non-latin1 - if ("\u00b5".compareToIgnoreCase("X") < 0) - throw new RuntimeException("Comparison failure1"); - } - - private void testTriplet(String one, String two, String three) - throws Exception { - if (one.compareToIgnoreCase(two) > 0) - throw new RuntimeException("Comparison failure1"); - if (two.compareToIgnoreCase(three) > 0) - throw new RuntimeException("Comparison failure2"); - if (three.compareToIgnoreCase(one) < 0) - throw new RuntimeException("Comparison failure3"); + testTriplet(test1, test2, test3); + } + + /** + * Compares a trio of strings for legacy test {@link #compareToIgnoreCase_Triplets}. + * + * @param one string used by test comparisons + * @param two string used by test comparisons + * @param three string used by test comparisons + */ + @SuppressWarnings("SameParameterValue") + private void testTriplet(final String one, final String two, final String three) { + + if (compareToIgnoreCase(one, two) > 0) + fail("Comparison failure 1 for bug 4124769."); + if (compareToIgnoreCase(two, three) > 0) + fail("Comparison failure 2 for bug 4124769."); + if (compareToIgnoreCase(three, one) < 0) + fail("Comparison failure 3 for bug 4124769."); + } + + @Test + public void testStringsOfEqualLength() { + + // Note: Full-width latin letters (uppercase U+FF21 to U+FF3A, and lowercase + // U+FF41 to U+FF5A) are case-insensitively equal to each other, but + // not to their ASCII counterparts. + + // Test equal-length strings exhibiting case-insensitive equality. + + testEqualStringsIC("\uFF21", "\uFF41" ); // "A" vs. "a". + testEqualStringsIC("\uFF21\uFF22", "\uFF41\uFF42" ); // "AB" vs. "ab". + testEqualStringsIC("\uFF21\uFF22\uFF23", "\uFF41\uFF42\uFF43" ); // "ABC" vs. "abc". + testEqualStringsIC("\uFF21\uFF22\uFF23\uFF24", "\uFF41\uFF42\uFF43\uFF44"); // "ABCD" vs. "abcd". + testEqualStringsIC("\uFF21\uFF22\uFF23\uFF24", new String("\uFF21\uFF22\uFF23\uFF24".toCharArray())); // Test identical strings ("ABCD") without "String" object reference equality interfering. + + // Test equal-length strings exhibiting case-insensitive inequality. + + testUnequalStringsIC("\uFF21\uFF22cd", "\uFF41\uFF42\uFF43\uFF44"); // "ABcd" vs. "abcd". + } + + @Test + public void testStringsOfUnequalLength() { + + // Note: Full-width latin letters (uppercase U+FF21 to U+FF3A, and lowercase + // U+FF41 to U+FF5A) are case-insensitively equal to each other, but + // not to their ASCII counterparts. + + // Test strings whose overlapping portions are equal, so + // inequality emerges only from their length difference. + + testUnequalStringsIC("\uFF21\uFF22\uFF23\uFF24", "\uFF41\uFF42\uFF43\uFF44\uFF45"); // "ABCD" vs. "abcde". + testUnequalStringsIC("\uFF41\uFF42\uFF43\uFF44", "\uFF21\uFF22\uFF23\uFF24\uFF25"); // "abcd" vs. "ABCDE". + + + // Test strings whose overlapping portions are unequal, so + // inequality originates in the comparison of their overlap, + // rather than their length difference. + + testUnequalStringsIC("\uFF41\uFF42\uFF43\uFF44\uFF45", "\uFF21\uFF22\uFF23\uFF38"); // "abcde" vs. "ABCX". + + testUnequalStringsIC("\uFF21\uFF22\uFF23\uFF24", "\uFF41\uFF42\uFF43\uFF58\uFF59\uFF5A"); // "ABCD" vs. "abcxyz". + testUnequalStringsIC("\uFF41\uFF42\uFF43\uFF44", "\uFF21\uFF22\uFF23\uFF38\uFF39\uFF3A"); // "abcd" vs. "ABCXYZ". + } + + @Test + public void testUnpairedSurrogates_HighVsHigh() { + testUnpairedSurrogates("\uD800", "\uDBFF"); + } + + @Test + public void testUnpairedSurrogates_LowVsLow() { + testUnpairedSurrogates("\uDC00", "\uDFFF"); + } + + @Test + public void testUnpairedSurrogates_HighVsLow() { + testUnpairedSurrogates("\uD800", "\uDC00"); + } + + private void testUnpairedSurrogates + ( + final String unpairedSurrogateLesser, + final String unpairedSurrogateGreater + ){ + testUnequalStringsIC( unpairedSurrogateLesser , unpairedSurrogateGreater ); + testUnequalStringsIC("0" + unpairedSurrogateLesser , "0" + unpairedSurrogateGreater ); + testUnequalStringsIC( unpairedSurrogateLesser + "1", unpairedSurrogateGreater + "1"); + testUnequalStringsIC("0" + unpairedSurrogateLesser + "2", "0" + unpairedSurrogateGreater + "2"); + + // Compare unpaired surrogate with greater and lesser 16-bit BMP code-points. + + testUnequalStringsIC("0" + unpairedSurrogateLesser + "2", "0\uFF112"); + testUnequalStringsIC("0\u20812", "0" + unpairedSurrogateLesser + "2"); + } + + @Test + public void testSurrogatePairs_UnequalHighVsEqualLow() { + testUnequalStringsIC("\uD800\uDC00", "\uD801\uDC00"); + } + + @Test + public void testSurrogatePairs_EqualHighVsUnequalLow() { + testUnequalStringsIC("\uD800\uDC00", "\uD800\uDC01"); + } + + @Test + public void testSurrogatePairs_EqualHighVsInvalidLow() { + + // One invalid low-surrogate. + + testUnequalStringsIC("\uD800\uBAD1", "\uD800\uDC00"); + + // Two invalid low-surrogates. + + testUnequalStringsIC("\uD800\uBAD1", "\uD800\uBAD2"); + } + + private void testEqualStringsIC + ( + @SuppressWarnings("SameParameterValue") + final String stringA, // String case-insensitively equal to "stringB". + final String stringB // String case-insensitively equal to "stringA". + ){ + try ( + final Formatter error = new Formatter(new StringBuilder(0)) // If the test succeeds, this "StringBuilder" remains zero-length. + ){ + + // Test comparison, as used in sorting. + // + // These tests fail if "stringA" is not identified by + // "compareToIgnoreCase" as equal to "stringB". + + { + int signum; + + signum = compareToIgnoreCase(stringA, stringB); + if (signum != 0) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getCompareToIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringA), + /* 2 */ 0, + /* 3 */ stringA.length(), + /* 4 */ StringLiteral.from(stringB), + /* 5 */ 0, + /* 6 */ stringB.length() + ).format( + " returned %d instead of zero.", + signum + ); + } + + signum = compareToIgnoreCase(stringB, stringA); + if (signum != 0) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getCompareToIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringB), + /* 2 */ 0, + /* 3 */ stringB.length(), + /* 4 */ StringLiteral.from(stringA), + /* 5 */ 0, + /* 6 */ stringA.length() + ).format( + " returned %d instead of zero.", + signum + ); + } + } + + // Test equality testing. + // + // These tests fail if "equalsIgnoreCase" returns "false". + + if (!equalsIgnoreCase(stringA, stringB)) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getEqualsIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringA), + /* 2 */ 0, + /* 3 */ stringA.length(), + /* 4 */ StringLiteral.from(stringB), + /* 5 */ 0, + /* 6 */ stringB.length() + ).format( + " returned \"false\" instead of \"true\"." + ); + } + + if (!equalsIgnoreCase(stringB, stringA)) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getEqualsIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringB), + /* 2 */ 0, + /* 3 */ stringB.length(), + /* 4 */ StringLiteral.from(stringA), + /* 5 */ 0, + /* 6 */ stringA.length() + ).format( + " returned \"false\" instead of \"true\"." + ); + } + + // If the "StringBuilder" used by "error" is not empty, one or more tests failed, so invoke "fail". + + error.flush(); + + if (!((CharSequence) error.out()).isEmpty()) { + + fail( + "testEqualStringsIC(" + StringLiteral.from(stringA) + + ", " + StringLiteral.from(stringB) + ") found test failure(s):" + + error + ); + } + } + } + + private void testUnequalStringsIC + ( + @SuppressWarnings("SameParameterValue") + final String stringLesser, // String case-insensitively less than "stringGreater". + final String stringGreater // String case-insensitively greater than "stringLesser". + ){ + try ( + final Formatter error = new Formatter(new StringBuilder(0)) // If the test succeeds, this "StringBuilder" remains zero-length. + ){ + + // Test comparison, as used in sorting. + // + // These tests fail if "stringLesser" is not identified by + // "compareToIgnoreCase" as less than "stringGreater". + + { + int signum; + + signum = compareToIgnoreCase(stringLesser, stringGreater); + if (signum >= 0) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getCompareToIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringLesser), + /* 2 */ 0, + /* 3 */ stringLesser.length(), + /* 4 */ StringLiteral.from(stringGreater), + /* 5 */ 0, + /* 6 */ stringGreater.length() + ).format( + " returned %d instead of a negative value.", + signum + ); + } + + signum = compareToIgnoreCase(stringGreater, stringLesser); + if (signum <= 0) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getCompareToIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringGreater), + /* 2 */ 0, + /* 3 */ stringGreater.length(), + /* 4 */ StringLiteral.from(stringLesser), + /* 5 */ 0, + /* 6 */ stringLesser.length() + ).format( + " returned %d instead of a positive value.", + signum + ); + } + } + + // Test equality testing. + // + // (As this method's name makes clear, its inputs must be case-insensitively *unequal*, + // so these tests fail if "equalsIgnoreCase" returns "true".) + + if (equalsIgnoreCase(stringLesser, stringGreater)) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getEqualsIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringLesser), + /* 2 */ 0, + /* 3 */ stringLesser.length(), + /* 4 */ StringLiteral.from(stringGreater), + /* 5 */ 0, + /* 6 */ stringGreater.length() + ).format( + " returned \"true\" instead of \"false\"." + ); + } + + if (equalsIgnoreCase(stringGreater, stringLesser)) { + + error.format( + "%n * Method %s.", + getTestedClassFQN() + ).format( + getEqualsIgnoreCaseFormatterString(), + /* 1 */ StringLiteral.from(stringGreater), + /* 2 */ 0, + /* 3 */ stringGreater.length(), + /* 4 */ StringLiteral.from(stringLesser), + /* 5 */ 0, + /* 6 */ stringLesser.length() + ).format( + " returned \"true\" instead of \"false\"." + ); + } + + // If the "StringBuilder" used by "error" is not empty, one or more tests failed, so invoke "fail". + + error.flush(); + + if (!((CharSequence) error.out()).isEmpty()) { + + fail( + "testUnequalStringsIC(" + StringLiteral.from(stringLesser) + + ", " + StringLiteral.from(stringGreater) + ") found test failure(s):" + + error + ); + } + } + } + + @Test + public void allCodePointsDifferingOnlyInCaseAreEqual_equalsIgnoreCase() { + + // If the test "validatePremise_AllSMPCodePointCaseVariantsAreSMPCodePoints", + // or "validatePremise_AllSMPCodePointCaseVariantsUseTheSameHighSurrogate", + // reports, for example: + // + // "Of 1,048,576 SMP code-points, 450 are assigned, public and affected + // by case-conversion." + // + // ...then expect a total failure of this test to report 225 errors (450/2), + // because errors unaffected by parameter order are reported only on their + // first occurrence (assuming the test's code-point loop operates in ascending + // order). + // + // That expectation would not apply if a case conversion error occurred among + // the Basic Multilingual Plane code-points, but that has not been an issue, + // historically. + + testAllAssignedPublicCodePointsForCaseInsensitiveEquality( + getTestedClassFQN(), + getEqualsIgnoreCaseMethodName(), + getEqualsIgnoreCaseFormatterString() + " returned \"%10$s\", not \"true\"", + this::equalsIgnoreCase, + // No result conversion needed. If "equalsIgnoreCase" works as expected, + // "true" is returned. If "false" is returned, something went wrong. + r -> r + ); + } + + @Test + public void allCodePointsDifferingOnlyInCaseAreEqual_compareToIgnoreCase() { + + // If the test "validatePremise_AllSMPCodePointCaseVariantsAreSMPCodePoints", + // or "validatePremise_AllSMPCodePointCaseVariantsUseTheSameHighSurrogate", + // reports, for example: + // + // "Of 1,048,576 SMP code-points, 450 are assigned, public and affected + // by case-conversion." + // + // ...then expect a total failure of this test to report 225 errors (450/2), + // because errors unaffected by parameter order are reported only on their + // first occurrence (assuming the test's code-point loop operates in ascending + // order). + // + // That expectation would not apply if a case conversion error occurred among + // the Basic Multilingual Plane code-points, but that has not been an issue, + // historically. + + testAllAssignedPublicCodePointsForCaseInsensitiveEquality( + getTestedClassFQN(), + getCompareToIgnoreCaseMethodName(), + getCompareToIgnoreCaseFormatterString() + " returned %10$s, not 0", + this::compareToIgnoreCase, + // Convert the result to a boolean. If "compareToIgnoreCase" works as expected, + // zero is returned, and this function converts it to "true". If a non-zero value + // is returned, something went wrong, and this function converts it to "false". + r -> r == 0 + ); + } + + private static <R> void testAllAssignedPublicCodePointsForCaseInsensitiveEquality + ( + final String testedClassName, + final String testedMethodName, + final String testMethodInvocationFailureFormat, + final BiFunction<String,String,R> testFunction, + final Predicate<R> testResultValidator + ){ + final String toUcFormat = "%n U+%7$04X - Character.toUpperCase(0x%8$04X) returned code-point U+%9$04X, but " + testMethodInvocationFailureFormat + '.'; + final String toLcFormat = "%n U+%7$04X - Character.toLowerCase(0x%8$04X) returned code-point U+%9$04X, but " + testMethodInvocationFailureFormat + '.'; + final String toLcToUcFormat = "%n U+%7$04X - Character.toLowerCase(Character.toUpperCase(0x%8$04X)) returned code-point U+%9$04X, but " + testMethodInvocationFailureFormat + '.'; + + try ( + final Formatter error = new Formatter(new StringBuilder(0)) // If the test succeeds, this "StringBuilder" remains zero-length. + ){ + int failures = 0; + + // Examine *every* Unicode code-point. + + for (int codePoint = Character.MIN_CODE_POINT; codePoint <= Character.MAX_CODE_POINT; codePoint++) { + final int codePointType = Character.getType(codePoint); + + // Skip this code-point/-unit, if case is irrelevant to its type (Unicode category). + + if (codePointType == Character.UNASSIGNED || codePointType == Character.PRIVATE_USE || codePointType == Character.SURROGATE) + continue; + + // Replicate both conversions potentially performed by case-insensitive comparison: + // 1. Convert the code-point to uppercase. + // 2. Convert the uppercase code-point to lowercase. + + final int codePointUc = Character.toUpperCase(codePoint ); + final int codePointLc = Character.toLowerCase(codePointUc); + + // Skip this code-point, if neither case-conversion affected it. + + if (codePoint == codePointUc && codePointUc == codePointLc) + continue; + + // KNOWN: "codePoint" is not equal to one or both of "codePointUc" and "codePointLc". + // Therefore, "codePoint" has upper- and/or lower-case counterparts, and is + // suitable for the following case-insensitive "String" equality validation tests. + + if (codePoint != codePointUc) { + + // KNOWN: "codePoint" is lowercase, because "toUpperCase(codePoint)" returned a different code-point. + // Therefore test "codePoint" vs. "codePointUc". + + if (!testMutualEqualityWithoutRedundantErrors(codePoint, testFunction, testResultValidator, codePoint, codePointUc, error, toUcFormat)) + failures++; + + if (codePoint != codePointLc) { + + // Triple-case code-point: There must be three distinct forms of "codePoint" (including itself). + // This is very rare, and all examples are Basic Multilingual Plane code-points, as of JDK 15.0.2 + // and Unicode 13.0.0. + + if (!testMutualEqualityWithoutRedundantErrors(codePoint, testFunction, testResultValidator, codePointUc, codePointLc, error, toLcToUcFormat)) + failures++; + } + + } else { // codePoint == codePointUc && codePointUc != codePointLc + + // KNOWN: "codePoint" is uppercase, because "toUpperCase(codePoint)" returned it. + // Therefore, test "codePoint" vs. "codePointLc". + + if (!testMutualEqualityWithoutRedundantErrors(codePoint, testFunction, testResultValidator, codePoint, codePointLc, error, toLcFormat)) + failures++; + } + } + + if (failures != 0) { + + error.format("%nTotal erroneous case-insensitive code-point comparisons: %,d.", failures).flush(); + fail("Method \"" + testedClassName + '.' + testedMethodName + "\" erroneously reported differences between case-insensitively equal code-points:" + error.out()); + } + } + } + + private static <R> boolean testMutualEqualityWithoutRedundantErrors + ( + final int testCodePoint, // Code-point currently being tested by the caller's code-point loop, which must operate in ascending order. + final BiFunction<String,String,R> comparisonFunction, // Case-insensitive comparison function invoked with "String" representations of "codePointA" and "codePointB" as its parameters (in that order, and reversed). + final Predicate<R> resultIsEquality, // Function to examine "comparisonFunction" result, returning "true" if it indicates equality, or "false" otherwise. + final int codePointA, // Code-point for equality test. + final int codePointB, // Code-point for equality test. + final Formatter out, // "Formatter" to which an error report, if any, will be written. + final String failureFormat // "Formatter" format "String". Parameters: (1) "testCodePoint" or "codePointA" in String literal format, (2) offset into "String" of parameter 1 code-point [always 0], + // (3) length of "String" of parameter 1 code-point [1 or 2], (4) "codePointB" in String literal format, (5) offset into "String" of "codePointB" [always 0], + ){ // (6) length of "String" of "codePointB" [1 or 2], (7) "testCodePoint", (8) parameter 1 code-point as "int", (9) "codePointB", and (10) "comparisonFunction" return value. + if (codePointA != codePointB) { + final String codePointAStr = Character.toString(codePointA); + final String codePointBStr = Character.toString(codePointB); + final R compareResult = comparisonFunction.apply(codePointAStr, codePointBStr); + + if (!resultIsEquality.test(compareResult)) { // If "resultIsEquality" judged that "compareResult" indicates inequality... + + // Failure. However, report the failure only if (1) this appears to be its first occurrence + // (assuming the caller is testing code-points in ascending order), or (2) "testCodePoint" is + // a rare triple-case code-point, or (3) performing the same test with parameters reversed + // produces an inconsistent result. + + if (testCodePoint <= codePointA && testCodePoint <= codePointB // This is the first occurrence of this particular failure, because the caller's ascending code-point loop has reached neither "codePointA" nor "codePointB". + || testCodePoint != codePointA && testCodePoint != codePointB // "testCodePoint" must be one of the very rare triple-case code-points. Always report errors associated with it. + || resultIsEquality.test(comparisonFunction.apply(codePointBStr, codePointAStr)) // Reversing the "comparisonFunction" parameters produced a different result. Report the lack of mutual equality. (This could be redundant.) + ){ + // Either this is the failure's first occurrence, or "testCodePoint" is a triple-case code- + // point, or the parameter-reversed test returned a result different from the first test. + + if (testCodePoint == codePointA || testCodePoint == codePointB) { + out.format( + failureFormat, // This is usually the caller's "toLc" or "toUc" format. For example, respectively, "Character.toLowerCase(0x%8$04X) == U+%9$04X" or "Character.toUpperCase(0x%8$04X) == U+%9$04X". + /* 1 */ StringLiteral.from(codePointA), + /* 2 */ 0, + /* 3 */ codePointLength(codePointA), + /* 4 */ StringLiteral.from(codePointB), + /* 5 */ 0, + /* 6 */ codePointLength(codePointB), + /* 7 */ testCodePoint, + /* 8 */ codePointA, + /* 9 */ codePointB, + /* 10 */ compareResult + ); + } else { // if (testCodePoint != codePointA && testCodePoint != codePointB)... + out.format( + failureFormat, // This should be the caller's "toLcToUc" format. For example, "Character.toLowerCase(Character.toUpperCase(0x%8$04X)) == U+%9$04X". + /* 1 */ StringLiteral.from(testCodePoint), + /* 2 */ 0, + /* 3 */ codePointLength(testCodePoint), + /* 4 */ StringLiteral.from(codePointB), + /* 5 */ 0, + /* 6 */ codePointLength(codePointB), + /* 7 */ testCodePoint, + /* 8 */ testCodePoint, + /* 9 */ codePointB, + /* 10 */ compareResult + ); + } + + return false; // The test failed, and this should be the error's first occurrence. + } + } + } + + // The test was either unnecessary ("codePointA == codePointB"), or successful, or deemed + // a redundant failure to be ignored. + + return true; + } + + @Test + public void allTripleCaseCodePointsAreEqual_equalsIgnoreCase() { + + testTripleCaseCodePointEquality( + getTestedClassFQN(), + "equalsIgnoreCase", + getEqualsIgnoreCaseFormatterString() + " returned \"%10$s\", not \"true\"", + this::equalsIgnoreCase, + r -> r // "true" (equality) is the correct answer, so return "true" when "r" is "true", and "false" when "r" is "false". + ); + } + + @Test + public void allTripleCaseCodePointsAreEqual_compareToIgnoreCase() { + + testTripleCaseCodePointEquality( + getTestedClassFQN(), + "compareToIgnoreCase", + getCompareToIgnoreCaseFormatterString() + " returned %10$s, not 0", + this::compareToIgnoreCase, + r -> r == 0 // Zero (equality) is the correct answer. Return "true" when "r" is zero. + ); + } + + private static <R> void testTripleCaseCodePointEquality + ( + final String testedClassName, + final String testedMethodName, + final String testedMethodFormatterString, + final BiFunction<String,String,R> testFunction, + final Predicate<R> testResultValidator + ){ + try ( + final Formatter error = new Formatter(new StringBuilder(0)) // If the test succeeds, this "StringBuilder" remains zero-length. + ){ + // Test each of the triple-case code-points. (Other test methods in this class test + // these code-points, but they do not single-out these code-points, or supply a bug's + // probable fix.) + + final String toUcFormat = " U+%7$04X - Character.toUpperCase(0x%8$04X) returned code-point U+%9$04X, but " + testedMethodFormatterString + ".%n"; + final String toLcFormat = " U+%7$04X - Character.toLowerCase(0x%8$04X) returned code-point U+%9$04X, but " + testedMethodFormatterString + ".%n"; + final String toLcToUcFormatCpLc = " U+%7$04X - Character.toLowerCase(Character.toUpperCase(0x%<04X)) returned code-point U+%9$04X, but " + testedMethodFormatterString + ".%n"; + final String toLcToUcFormatLcCp = " U+%7$04X - Character.toLowerCase(Character.toUpperCase(0x%<04X)) returned code-point U+%8$04X, but " + testedMethodFormatterString + ".%n"; + final int[] tripleCaseCodePoints = getTripleCaseCodePoints(); + int failures = 0; + + for (final int codePoint : tripleCaseCodePoints) { + final int codePointUc = Character.toUpperCase(codePoint ); + final int codePointLc = Character.toLowerCase(codePointUc); + + if (!testMutualEqualityWithoutRedundantErrors(codePoint, testFunction, testResultValidator, codePoint, codePointUc, error, toUcFormat)) + failures++; + if (!testMutualEqualityWithoutRedundantErrors(codePoint, testFunction, testResultValidator, codePointUc, codePointLc, error, toLcFormat)) + failures++; + if (!testMutualEqualityWithoutRedundantErrors(codePoint, testFunction, testResultValidator, codePoint, codePointLc, error, toLcToUcFormatCpLc)) + failures++; + + // Repeat the preceding test with the code-points reversed. The repetition is necessary to + // achieve full coverage of any implementation with a "compareCodePointsIgnoringCase" method + // using a pair of "switch" expressions (which should contain identical "case" clauses). + + if (!testMutualEqualityWithoutRedundantErrors(codePoint, testFunction, testResultValidator, codePointLc, codePoint, error, toLcToUcFormatLcCp)) + failures++; + } + + if (failures != 0) { + + error.format("%nReplacement for \"switch\" expression in \"StringUTF16.getCIComparisonCodePoint\":%n%n"); + generateTripleCaseCodePointsSwitchExpression(error, "Code-Point Progression by Name", Character::getName, tripleCaseCodePoints); + // generateTripleCaseCodePointsSwitchExpression(error, "Unicode Block Progression", Character.UnicodeBlock::of, tripleCaseCodePoints); + + error.flush(); + fail( + """ + Triple-case code-point case-insensitive equality test failed by "%s.%s".%n\ + TRY: Replace each "switch" expression in "%1$s.getCIComparisonCodePoint"%n\ + with the new expression at this message's end.%n\ + %n\ + Individual Failures:%n\ + %s\ + """.formatted( + testedClassName, + testedMethodName, + error.out() + ) + ); + } + } + } + + private static int[] getTripleCaseCodePoints() { + @SuppressWarnings("MagicNumber") + int[] tripleCaseCodePoints = new int[27]; // 27 was the correct number of triple-case code-points as of JDK 15.0.2 and Unicode 13.0, but this array will grow, if necessary. + int tripleCaseCodePointsIdx = 0; + + for (int codePoint = Character.MIN_CODE_POINT; codePoint <= Character.MAX_CODE_POINT; codePoint++) { + final int codePointUc = Character.toUpperCase(codePoint); + + if (codePoint == codePointUc) + continue; + + final int codePointLc = Character.toLowerCase(codePointUc); + + if (codePointUc == codePointLc || codePoint == codePointLc) + continue; + + // "codePoint" has, in effect, three cases (instead of just uppercase and lowercase). + + // Increase size of array "tripleCaseCodePoints", if necessary. + + if (tripleCaseCodePoints.length == tripleCaseCodePointsIdx) { + //noinspection ObjectAllocationInLoop + tripleCaseCodePoints = Arrays.copyOf(tripleCaseCodePoints, tripleCaseCodePoints.length << 1); + } + + // Add "codePoint" to array "tripleCaseCodePoints". + + tripleCaseCodePoints[tripleCaseCodePointsIdx++] = codePoint; + } + + return tripleCaseCodePoints.length == tripleCaseCodePointsIdx ? tripleCaseCodePoints : Arrays.copyOf(tripleCaseCodePoints, tripleCaseCodePointsIdx); } - + + /** + * Generates the triple-case code-point "switch" expression used in method "{@code + * java.lang.StringUTF16.getCIComparisonCodePoint}", allowing expression generation + * independent of the these tests or their outcomes. + * + * @return source code for "switch" expression in {@code StringUTF16.getCIComparisonCodePoint}"}, + * generated based on the operative JDK's Unicode data + */ + public static String generateTripleCaseCodePointsSwitchExpression() { + + try ( + final Formatter out = new Formatter(new StringBuilder(5 * 1_024)) + ){ + generateTripleCaseCodePointsSwitchExpression(out, "Code-Point Progression by Name", Character::getName, getTripleCaseCodePoints()); + // generateTripleCaseCodePointsSwitchExpression(out, "Unicode Block Progression", Character.UnicodeBlock::of, getTripleCaseCodePoints()); + + out.flush(); + return out.out().toString(); + } + } + + /** + * Generates the triple-case code-point "switch" expression used in method "{@code + * java.lang.StringUTF16.getCIComparisonCodePoint}", writing it to the supplied {@link Formatter}. + * + * @param out {@code Formatter} to which the "switch" expression is written + * @param symbolicProgressionTitle title of column representing code-point progression using names + * (instead of code-point numbers) + * @param symbolicNameAccessor function accepting a code-point and returning an object whose + * {@code toString} method provides a name relevant to the code-point + * @param tripleCaseCodePoints array containing every triple-case code-point, sorted in ascending + * order. Normally supplied by {@link #getTripleCaseCodePoints()}. + */ + private static void generateTripleCaseCodePointsSwitchExpression + ( + final Formatter out, + @SuppressWarnings("SameParameterValue") + final String symbolicProgressionTitle, + final IntFunction<Object> symbolicNameAccessor, + final int[] tripleCaseCodePoints // Sorted in ascending order. + ){ + final boolean bmpOnly = tripleCaseCodePoints[tripleCaseCodePoints.length - 1] >>> Character.SIZE == 0; // Is the greatest code-point within the Basic Multilingual Plane? + final String switchExpressionLine = "switch (codePoint) {"; + final String columnCPPTitle = "Code-Point Progression"; + final int columnCPPCodePoints; // Width of "Code-Point Progression" column in code-points. + final String columnCPPLine; // Column header/footer line, a sequence of HYPHEN-MINUS (U+002D) characters. + final String columnGap = " "; // Six spaces. + final int caseCodePoints = 30; // Width of "case" clauses in code-points. There are two formats: " case '\u0000' -> '\u0000';" and " case 0x000000 -> 0x000000;". Both happen to be the same length. + final int commentAbsoluteIndentCodePoints = Math.max(codePointCount(switchExpressionLine), caseCodePoints) + 4; // Indent, from left margin, of the comments documenting code-point and Unicode block progressions. + final String commentAbsoluteIndent = " ".repeat(commentAbsoluteIndentCodePoints); + final String caseCommentGap = " ".repeat(commentAbsoluteIndentCodePoints - caseCodePoints); // Gap between "case" semicolon and line-comment start. + final String caseFormat; + final TripleCaseCodePoints tccpInfo = new TripleCaseCodePoints(tripleCaseCodePoints, symbolicNameAccessor); + final int columnSNPCodePoints = tccpInfo.name3cCodePointsMax + 4 + tccpInfo.nameUcCodePointsMax + 4 + tccpInfo.nameLcCodePointsMax; // Width of symbolic name progression (SNP) column in code-points. + final String columnSNPLine = "-".repeat(columnSNPCodePoints); // Column header/footer line, a sequence of HYPHEN-MINUS (U+002D) characters. + + if (bmpOnly) { // Code-points from Basic Multilingual Plane (BMP) only. + + //noinspection StringConcatenationMissingWhitespace + caseFormat = " case '\\u%1$04X' -> '\\u%3$04X';%4$s// U+%1$04X -> U+%2$04X -> U+%3$04X%5$s%6$-" + tccpInfo.name3cCodePointsMax + "s -> %7$-" + tccpInfo.nameUcCodePointsMax + "s -> %8$s%n"; + columnCPPCodePoints = 2 + 4 + 4 + 2 + 4 + 4 + 2 + 4; // For example, "U+00B5 -> U+039C -> U+03BC". + + } else { // Code-points from both BMP and Supplementary Multilingual Plane. + + //noinspection StringConcatenationMissingWhitespace + caseFormat = " case 0x%1$06X -> 0x%3$06X;%4$s// U+%1$06X -> U+%2$06X -> U+%3$06X%5$s%6$-" + tccpInfo.name3cCodePointsMax + "s -> %7$-" + tccpInfo.nameUcCodePointsMax + "s -> %8$s%n"; + columnCPPCodePoints = 2 + 6 + 4 + 2 + 6 + 4 + 2 + 6; // For example, "U+0000B5 -> U+00039C -> U+0003BC". + } + + columnCPPLine = "-".repeat(columnCPPCodePoints); + + out.format( // Comment line: title. + "%s// Triple-Case Code-Points, as of Java %s. (Written by \"%s.generateTripleCaseCodePointsSwitchExpression\".)%n", + commentAbsoluteIndent, + System.getProperty("java.version"), + CompareIC.class.getName() + ); + out.format("%s// %n", commentAbsoluteIndent); + out.format( // Comment line: column titles. + "%s// %s%s%s%s%n", + commentAbsoluteIndent, + columnCPPTitle, + " ".repeat(columnCPPCodePoints - codePointCount(columnCPPTitle)), + columnGap, + symbolicProgressionTitle + ); + out.format( // Comment line: column horizontal lines. + "%s%s// %s%s%s%n", + switchExpressionLine, + " ".repeat(commentAbsoluteIndentCodePoints - codePointCount(switchExpressionLine)), + columnCPPLine, + columnGap, + columnSNPLine + ); + + for (final TripleCaseCodePoint tccpDatum : tccpInfo.tccpData) { + + out.format( + caseFormat, + /* 1 */ tccpDatum.codePoint3c, + /* 2 */ tccpDatum.codePointUc, + /* 3 */ tccpDatum.codePointLc, + /* 4 */ caseCommentGap, + /* 5 */ columnGap, + /* 6 */ tccpDatum.codePoint3cName, + /* 7 */ tccpDatum.codePointUcName, + /* 8 */ tccpDatum.codePointLcName + ); + } + + out.format("%s// %s%s%s%n", commentAbsoluteIndent, columnCPPLine, columnGap, columnSNPLine); // Comment line: column horizontal lines. + out.format( + """ + // All other case-sensitive code-points are either uppercase (in which case they are changed%n\ + // below), or lowercase already (in which case they are not). Therefore, only "toLowerCase"%n\ + // is necessary. Code-units and case-insensitive code-points are unchanged by "toLowerCase".%n\ + default -> Character.toLowerCase(codePoint);%n\ + };%n\ + """ + ); + } + + /** + * Test premise: "Case-insensitive equality exists only among Supplementary Multilingual Plane (SMP) + * code-points UTF-16 encoded using the same high-surrogate code-unit." This premise, known as "Unicode Empirical + * Property no. 1" in {@link java.lang.StringUTF16} (see {@link java.lang.StringUTF16#regionMatchesCI + * regionMatchesCI} implementation notes), is valid for Unicode versions up to (at least) 13.0.0. It allows an + * optimization of UTF-16 case-insensitive comparison: Surrogate pairs using different high-surrogates prove + * inequality, therefore the comparison may terminate without performing either UTF-16 decoding, or + * case-insensitive code-point comparison. (In the case of {@link java.lang.StringUTF16#compareToCI}, returning + * the difference between the high-surrogates is correct.) + * + * If this premise ceases to be valid (in other words, if this test fails), methods {@code java.lang.StringUTF16#regionMatchesCI} + * and {@link java.lang.StringUTF16#compareToCI}) will require de-optimization: They must test for case-insensitive + * equality between all SMP code-points. + * + * That optimization cannot be guaranteed safe for Java code in general, because the code could, someday, run in + * the JVM of a Java version whose {@link Character} class represents a Unicode version with a case-sensitive SMP + * code-point arrangement invalidating this premise. Conversely, the optimization is guaranteed safe for the code of + * each Java version passing this test, because that code can encounter only the Unicode version built into its + * {@code Character} class. While this premise holds true, this optimization allows code outside the JDK to benefit + * from the JDK's unique certainty about the operative Unicode version. + * + * + * @see #validatePremise_AllSMPCodePointCaseVariantsAreSMPCodePoints() + * @see #validatePremise_AllBMPCodePointCaseVariantsAreBMPCodePoints() + */ + @SuppressWarnings("JavadocReference") + @Test + public void validatePremise_AllSMPCodePointCaseVariantsUseTheSameHighSurrogate() { + + System.out.println(); + System.out.printf( + "PREMISE: Case-insensitive equality exists only among Supplementary Multilingual Plane (SMP) code-points UTF-16%n" + + "encoded using the same high-surrogate code-unit.%n" + ); + + int invalidatingCases = 0; + int caseSensitiveCodePoints = 0; + + for (int codePoint = Character.MIN_SUPPLEMENTARY_CODE_POINT; codePoint <= Character.MAX_CODE_POINT; codePoint++) { + final int codePointType = Character.getType(codePoint); + + if (codePointType == Character.UNASSIGNED || codePointType == Character.PRIVATE_USE) + continue; + + final int codePointUc = Character.toUpperCase(codePoint ); + final int codePointLc = Character.toLowerCase(codePointUc); + + if (codePoint == codePointUc && codePointUc == codePointLc) + continue; + + caseSensitiveCodePoints++; + + if (codePoint >>> 10 != codePointUc >>> 10) { + + System.out.printf( + " > INVALIDATION: toUpperCase(U+%06X) == U+%06X. Their high-surrogates differ: U+%04X != U+%04X.%n", + codePoint, + codePointUc, + Character.MIN_HIGH_SURROGATE | (codePoint - Character.MIN_SUPPLEMENTARY_CODE_POINT >>> 10), + Character.MIN_HIGH_SURROGATE | (codePointUc - Character.MIN_SUPPLEMENTARY_CODE_POINT >>> 10) + ); + + invalidatingCases++; + } + + if (codePointUc >>> 10 != codePointLc >>> 10) { + + System.out.printf( + " > INVALIDATION: toLowerCase(U+%06X) == U+%06X. Their high-surrogates differ: U+%04X != U+%04X.%n", + codePointUc, + codePointLc, + Character.MIN_HIGH_SURROGATE | (codePointUc - Character.MIN_SUPPLEMENTARY_CODE_POINT >>> 10), + Character.MIN_HIGH_SURROGATE | (codePointLc - Character.MIN_SUPPLEMENTARY_CODE_POINT >>> 10) + ); + + invalidatingCases++; + } + } + + System.out.printf( + " * Of %,d SMP code-points, %,d are assigned, public and affected by case-conversion.%n" + + " * Tested case variants of those %<,d SMP code-points for unequal high-surrogates.%n" + + " * Found %s.%n", + Character.MAX_CODE_POINT - Character.MIN_SUPPLEMENTARY_CODE_POINT + 1, + caseSensitiveCodePoints, + invalidatingCases == 0 ? "none" : "%,d".formatted(invalidatingCases) + ); + + if (invalidatingCases != 0) + fail(String.format("TEST RESULT: Premise is false, because %,d case variants use different high-surrogates.", invalidatingCases)); + + System.out.printf( + "TEST RESULT: Premise is valid for operative Unicode version, because all SMP code-point case variants used%n" + + " common high-surrogates.%n%n" + ); + } + + /** + * Test premise: "For each Supplementary Multilingual Plane (SMP) code-point, {@link Character#toUpperCase(int)} + * and {@code Character.toLowerCase(Character.toUpperCase(int))} return a SMP code-point." In {@code + * java.lang.StringUTF16}, this premise is referred to as "Unicode empirical property no. 2". + * + * Someday, {@link Character} might provide a version of Unicode (greater than 13.0) invalidating that premise. + * If so, it will break all case-insensitive Unicode equality comparisons requiring equal-length inputs (measured in + * "{@code char}" primitives, instead of code-points). For example, {@link String#equalsIgnoreCase} will break. + * + * However, even after resolving all aspects of the length issue everywhere it hides, methods {@code + * java.lang.StringUTF16#compareToCI} and {@code java.lang.StringUTF16#regionMatchesCI} would still be broken, + * because this premise, and {@linkplain #validatePremise_AllBMPCodePointCaseVariantsAreBMPCodePoints() another}, + * are the bases of an optimization: unequal code-points are tested for case-insensitive equality only when both + * belong to either the Basic Multilingual Plane, or the SMP. (In the SMP case, a further optimization relies on + * a {@linkplain #validatePremise_AllSMPCodePointCaseVariantsUseTheSameHighSurrogate() further premise} tested by + * this class.) + * + * + * @see #validatePremise_AllBMPCodePointCaseVariantsAreBMPCodePoints + * @see #validatePremise_AllSMPCodePointCaseVariantsUseTheSameHighSurrogate + */ + @Test + public void validatePremise_AllSMPCodePointCaseVariantsAreSMPCodePoints() { + + System.out.println(); + System.out.println("PREMISE: All Supplementary Multilingual Plane (SMP) code-points are case-converted to SMP code-points."); + + int invalidatingCases = 0; + int caseSensitiveCodePoints = 0; + + for (int codePoint = Character.MIN_SUPPLEMENTARY_CODE_POINT; codePoint <= Character.MAX_CODE_POINT; codePoint++) { + final int codePointType = Character.getType(codePoint); + + if (codePointType == Character.UNASSIGNED || codePointType == Character.PRIVATE_USE) + continue; + + final int codePointUc = Character.toUpperCase(codePoint ); + final int codePointLc = Character.toLowerCase(codePointUc); + + if (codePoint == codePointUc && codePointUc == codePointLc) + continue; + + caseSensitiveCodePoints++; + + if (codePointUc < Character.MIN_SUPPLEMENTARY_CODE_POINT) { + + System.out.printf(" > INVALIDATION: toUpperCase(0x%06X) == 0x%04X.%n", codePoint, codePointUc); + invalidatingCases++; + + } else if (codePointLc < Character.MIN_SUPPLEMENTARY_CODE_POINT) { + + System.out.printf(" > INVALIDATION: toLowerCase(toUpperCase(0x%06X)) == 0x%04X.%n", codePoint, codePointLc); + invalidatingCases++; + } + } + + System.out.printf( + " * Of %,d SMP code-points, %,d are assigned, public and affected by case-conversion.%n" + + " * Tested case variants of those %<,d SMP code-points for Basic Multilingual Plane (BMP) code-points.%n" + + " * Found %s.%n", + Character.MAX_CODE_POINT - Character.MIN_SUPPLEMENTARY_CODE_POINT + 1, + caseSensitiveCodePoints, + invalidatingCases == 0 ? "none" : "%,d".formatted(invalidatingCases) + ); + + if (invalidatingCases != 0) + fail(String.format("TEST RESULT: Premise is false, because %,d SMP code-points were case-converted to BMP code-points.", invalidatingCases)); + + System.out.printf("TEST RESULT: Premise is valid for operative Unicode version, because all case variants were also SMP code-points.%n%n"); + } + + /** + * Test premise: "For each Basic Multilingual Plane (BMP) code-point, {@link Character#toUpperCase(int)} + * and {@code Character.toLowerCase(Character.toUpperCase(int))} return a BMP code-point." In {@code + * java.lang.StringUTF16}, this premise is referred to as "Unicode empirical property no. 3". + * + * Someday, {@link Character} might provide a version of Unicode (greater than 13.0) invalidating that premise. + * If so, it will break all case-insensitive Unicode equality comparisons requiring equal-length inputs (measured in + * "{@code char}" primitives, instead of code-points). For example, {@link String#equalsIgnoreCase} will break. + * + * However, even after resolving all aspects of the length issue everywhere it hides, methods {@code + * java.lang.StringUTF16#compareToCI} and {@code java.lang.StringUTF16#regionMatchesCI} would still be broken, + * because this premise, and {@linkplain #validatePremise_AllSMPCodePointCaseVariantsAreSMPCodePoints() another}, + * are the bases of an optimization: unequal code-points are tested for case-insensitive equality only when both + * belong to either the BMP, or the Supplementary Multilingual Plane (SMP). (In the SMP case, a further optimization + * relies on a {@linkplain #validatePremise_AllSMPCodePointCaseVariantsUseTheSameHighSurrogate() further premise} + * tested by this class.) + * + * + * @see #validatePremise_AllSMPCodePointCaseVariantsAreSMPCodePoints() + * @see #validatePremise_AllSMPCodePointCaseVariantsUseTheSameHighSurrogate() + */ + @Test + public void validatePremise_AllBMPCodePointCaseVariantsAreBMPCodePoints() { + + System.out.println(); + System.out.println("PREMISE: All Basic Multilingual Plane (BMP) code-points are case-converted to BMP code-points."); + + int invalidatingCases = 0; + int caseSensitiveCodePoints = 0; + + for (int codePoint = Character.MIN_CODE_POINT; codePoint < Character.MIN_SUPPLEMENTARY_CODE_POINT; codePoint++) { + final int codePointType = Character.getType(codePoint); + + if (codePointType == Character.UNASSIGNED || codePointType == Character.PRIVATE_USE || codePointType == Character.SURROGATE) + continue; + + final int codePointUc = Character.toUpperCase(codePoint ); + final int codePointLc = Character.toLowerCase(codePointUc); + + if (codePoint == codePointUc && codePointUc == codePointLc) + continue; + + caseSensitiveCodePoints++; + + if (codePointUc >= Character.MIN_SUPPLEMENTARY_CODE_POINT) { + + System.out.printf(" > INVALIDATION: toUpperCase(U+%04X) == U+%06X.%n", codePoint, codePointUc); + invalidatingCases++; + + } else if (codePointLc >= Character.MIN_SUPPLEMENTARY_CODE_POINT) { + + System.out.printf(" > INVALIDATION: toLowerCase(toUpperCase(0x%04X)) == 0x%06X.%n", codePoint, codePointLc); + invalidatingCases++; + } + } + + System.out.printf( + " * Of %,d BMP code-points, %,d are assigned, public and affected by case-conversion.%n" + + " * Tested case variants of those %<,d BMP code-points for Supplementary Multilingual Plane (SMP) code-points.%n" + + " * Found %s.%n", + Character.MIN_SUPPLEMENTARY_CODE_POINT - (Character.MAX_SURROGATE - Character.MIN_SURROGATE + 1), + caseSensitiveCodePoints, + invalidatingCases == 0 ? "none" : "%,d".formatted(invalidatingCases) + ); + + if (invalidatingCases != 0) + fail(String.format("TEST RESULT: Premise is false, because %,d BMP code-points were case-converted to SMP code-points.", invalidatingCases)); + + System.out.printf("TEST RESULT: Premise is valid for operative Unicode version, because all case variants were also BMP code-points.%n%n"); + } + + @Test + public void validatePremise_SurrogatesAreUnchangedByCaseConversion() { + + for (char surrogate = Character.MIN_SURROGATE; surrogate <= Character.MAX_SURROGATE; surrogate++) { + + assertEquals(surrogate, Character.toUpperCase(surrogate)); + assertEquals(surrogate, Character.toLowerCase(surrogate)); + } + } + + private static int codePointLength + ( + final int codePoint + ){ + return codePoint >>> Character.SIZE == 0 ? 1 : 2; + } + + private static int codePointCount + ( + final String chars + ){ + return chars.codePointCount(0, chars.length()); + } + + + private static class TripleCaseCodePoints { + + final TripleCaseCodePoint[] tccpData; + final int name3cCodePointsMax; + final int nameUcCodePointsMax; + final int nameLcCodePointsMax; + + + @SuppressWarnings({ "ObjectAllocationInLoop", "LocalVariableHidesMemberVariable" }) + TripleCaseCodePoints + ( + final int[] codePoint3cArray, + final IntFunction<Object> codePointNameAccessor + ){ + final TripleCaseCodePoint[] tccpData = new TripleCaseCodePoint[codePoint3cArray.length]; + int name3cCodePointsMax = 0; + int nameUcCodePointsMax = 0; + int nameLcCodePointsMax = 0; + + for (int tccpIdx = 0; tccpIdx < tccpData.length; tccpIdx++) { + final TripleCaseCodePoint tccpDatum = new TripleCaseCodePoint(codePoint3cArray[tccpIdx], codePointNameAccessor); + final int cpNameCodePoints = codePointCount(tccpDatum.codePoint3cName); + final int ucNameCodePoints = codePointCount(tccpDatum.codePointUcName); + final int lcNameCodePoints = codePointCount(tccpDatum.codePointLcName); + + tccpData[tccpIdx] = tccpDatum; + + if (name3cCodePointsMax < cpNameCodePoints) + name3cCodePointsMax = cpNameCodePoints; + if (nameUcCodePointsMax < ucNameCodePoints) + nameUcCodePointsMax = ucNameCodePoints; + if (nameLcCodePointsMax < lcNameCodePoints) + nameLcCodePointsMax = lcNameCodePoints; + } + + this.tccpData = tccpData; + this.name3cCodePointsMax = name3cCodePointsMax; + this.nameUcCodePointsMax = nameUcCodePointsMax; + this.nameLcCodePointsMax = nameLcCodePointsMax; + } + } + + + private static class TripleCaseCodePoint { + + final int codePoint3c; + final String codePoint3cName; + final int codePointUc; + final String codePointUcName; + final int codePointLc; + final String codePointLcName; + + + TripleCaseCodePoint + ( + final int codePoint3c, + final IntFunction<Object> codePointNameAccessor + ){ + this.codePoint3c = codePoint3c; + this.codePoint3cName = codePointNameAccessor.apply(codePoint3c).toString(); + this.codePointUc = Character.toUpperCase(codePoint3c); + this.codePointUcName = codePointNameAccessor.apply(codePointUc).toString(); + this.codePointLc = Character.toLowerCase(codePointUc); + this.codePointLcName = codePointNameAccessor.apply(codePointLc).toString(); + } + } + + + private static final class StringLiteral { + + private static final char[] NIBBLES = "0123456789ABCDEF".toCharArray(); + private static final String[] ESCAPES = new String[128]; + + static { + ESCAPES['\b'] = "\\b"; + ESCAPES['\t'] = "\\t"; + ESCAPES['\n'] = "\\n"; + ESCAPES['\f'] = "\\f"; + ESCAPES['\r'] = "\\r"; + ESCAPES['"' ] = "\\\""; + ESCAPES['\\'] = "\\\\"; + ESCAPES[' ' ] = " "; // Avoids an extra conditional test. + } + + + static String from + ( + final int codePoint + ){ + try { + return append(new StringBuilder(14), codePoint).toString(); + } catch (final IOException e) { + throw new UncheckedIOException(e); // Operating on a "StringBuilder", this case cannot arise. + } + } + + static String from + ( + final String chars + ){ + try { + final StringBuilder output = append(new StringBuilder(chars.length()), chars); + + return chars.length() == output.length() ? chars : output.toString(); + + } catch (final IOException e) { + throw new UncheckedIOException(e); // Operating on a "StringBuilder", this case cannot arise. + } + } + + static CharSequence from + ( + final CharSequence chars + ){ + try { + final StringBuilder output = append(new StringBuilder(chars.length()), chars); + + return chars.length() == output.length() ? chars : output.toString(); + + } catch (final IOException e) { + throw new UncheckedIOException(e); // Operating on a "StringBuilder", this case cannot arise. + } + } + + static <T extends Appendable> T append + ( + final T out, + final int codePoint + ) + throws IOException + { + out.append("\"\\u"); + + if (codePoint >>> Character.SIZE == 0) { + + appendHex(out, 4, 4, codePoint).append('"'); + + } else { + + appendHex(out, 4, 4, Character.highSurrogate(codePoint)).append("\\u"); + appendHex(out, 4, 4, Character.lowSurrogate (codePoint)).append('"' ); + } + + return out; + } + + static <T extends Appendable> T append + ( + final T out, + final CharSequence chars + ) + throws IOException + { + out.append('"'); + + for (int charIdx = 0, charsRemaining = chars.length(); --charsRemaining >= 0; charIdx++) { + final char c = chars.charAt(charIdx); + + if (c < ESCAPES.length) { + final String escape = ESCAPES[c]; + + if (escape != null) { + out.append(escape); + continue; + } + } + + final int codePointCategory = Character.getType(c); + + if (codePointCategory == Character.UNASSIGNED // Also includes "permanently reserved" code-points. + || codePointCategory >= Character.SPACE_SEPARATOR + && codePointCategory <= Character.SURROGATE + ){ + // Represent whitespace, invisibles, Supplementary Multilingual Plane code-points, and so + // forth, using 16-bit Unicode escapes. "Character" class identifiers for those Unicode + // categories are: + // 0 - UNASSIGNED + // 12 - SPACE_SEPARATOR (the escape logic prevents encoding of code-point "SPACE", U+0020) + // 13 - LINE_SEPARATOR + // 14 - PARAGRAPH_SEPARATOR + // 15 - CONTROL + // 16 - FORMAT + // 17 - (unused) + // 18 - PRIVATE_USE + // 19 - SURROGATE + + appendHex(out.append("\\u"), 4, 4, c); + + } else + out.append(c); + } + + out.append('"'); + + return out; + } + + @SuppressWarnings("MagicNumber") + private static <T extends Appendable> T appendHex + ( + final T out, + @SuppressWarnings("SameParameterValue") + final int hexDigitsMin, + @SuppressWarnings("SameParameterValue") + final int hexDigitsMax, + final int value + ) + throws IOException + { + // NOTE: If necessary, this method can be made to support 64-bit values by changing "value" + // from "int" to "long", and replacing "Integer" class references with "Long". + + if (0 > hexDigitsMin || hexDigitsMin > hexDigitsMax || hexDigitsMax > Integer.SIZE >>> 2) + throw new IllegalArgumentException("Violation of parameter value constraints: 0 < \"hexDigitsMin\" (" + hexDigitsMin + ") < \"hexDigitsMax\" (" + hexDigitsMax + ") <= " + (Integer.SIZE >>> 2) + '.'); + + int shift = hexDigitsMax - 1 << 2; + int nibble = value >>> shift & 0xF; + + if (nibble == 0 && hexDigitsMin < hexDigitsMax) { + int optionalLeadingZeros = hexDigitsMax - hexDigitsMin; + + do { + + shift -= 4; // Ignore the current zero nibble. + nibble = value >>> shift & 0xF; // Read the next nibble. + + } while (nibble == 0 && --optionalLeadingZeros > 0); + } + + out.append(NIBBLES[nibble]); + + for (shift -= 4; shift >= 0; shift -= 4) + out.append(NIBBLES[value >>> shift & 0xF]); + + return out; + } + } }

1 0

RFR: 8264326: Modernize javax.script.ScriptEngineManager and related classes' implementation
by Attila Szegedi 30 Mar '21

30 Mar '21

I noticed that `javax.script.ScriptEngineManager` `getEngineByXxx` methods had a lot of code duplication among themselves, and even within each method. I refactored them into a modern unified implementation. While there I also took the opportunity to introduce `Objects.requireNonNull` in place of null checks followed by NPE throws, mark private fields final where possible, use lambdas for `doPrivileged` block, use `List.of` and `List.copyOf` where possible, and generally sanitize/deduplicate. ------------- Commit messages: - Tidy - require non null in SimpleBindings - Simplify SimpleScriptContext.scopes - Mark fields final where possible - Deduplicate registerEngineXxx methods - Misc tidying - Deduplicate exception reporting - Lambdify - Mark fields as final; eliminate now unnecessary init() method. - Deduplicate engine creation and setup code - ... and 4 more: https://git.openjdk.java.net/jdk/compare/a209ed01...f378f350 Changes: https://git.openjdk.java.net/jdk/pull/3229/files Webrev: https://webrevs.openjdk.java.net/?repo=jdk&pr=3229&range=00 Issue: https://bugs.openjdk.java.net/browse/JDK-8264326 Stats: 225 lines in 5 files changed: 38 ins; 142 del; 45 mod Patch: https://git.openjdk.java.net/jdk/pull/3229.diff Fetch: git fetch https://git.openjdk.java.net/jdk pull/3229/head:pull/3229 PR: https://git.openjdk.java.net/jdk/pull/3229

3 7

RFR: 8262503: Support records in Dynalink
by Attila Szegedi 30 Mar '21

30 Mar '21

8262503: Support records in Dynalink ------------- Commit messages: - Document behavior changes - Add support for records to Dynalink - Test the desired functionality Changes: https://git.openjdk.java.net/jdk/pull/2767/files Webrev: https://webrevs.openjdk.java.net/?repo=jdk&pr=2767&range=00 Issue: https://bugs.openjdk.java.net/browse/JDK-8262503 Stats: 165 lines in 8 files changed: 153 ins; 6 del; 6 mod Patch: https://git.openjdk.java.net/jdk/pull/2767.diff Fetch: git fetch https://git.openjdk.java.net/jdk pull/2767/head:pull/2767 PR: https://git.openjdk.java.net/jdk/pull/2767

2 3