Subject: Backport JDK-8323699: MessageFormat.toPattern() generates non-equivalent MessageFormat pattern
---
.../classes/java/text/MessageFormat.java | 76 +++-
.../MessageFormatToPatternTest.java | 364 ++++++++++++++++++
.../MessageFormatsByArgumentIndex.java | 8 +-
.../MessageFormat/MessageRegression.java | 6 +-
4 files changed, 442 insertions(+), 12 deletions(-)
create mode 100644 test/jdk/java/text/Format/MessageFormat/MessageFormatToPatternTest.java
diff --git a/src/java.base/share/classes/java/text/MessageFormat.java b/src/java.base/share/classes/java/text/MessageFormat.java
index 28d1474ad..659838c8a 100644
--- a/src/java.base/share/classes/java/text/MessageFormat.java
+++ b/src/java.base/share/classes/java/text/MessageFormat.java
@@ -548,6 +548,11 @@ public class MessageFormat extends Format {
* The string is constructed from internal information and therefore
* does not necessarily equal the previously applied pattern.
*
+ * @implSpec The implementation in {@link MessageFormat} returns a
+ * string that, when passed to a {@code MessageFormat()} constructor
+ * or {@link #applyPattern applyPattern()}, produces an instance that
+ * is semantically equivalent to this instance.
+ *
* @return a pattern representing the current state of the message format
*/
public String toPattern() {
@@ -559,6 +564,7 @@ public class MessageFormat extends Format {
lastOffset = offsets[i];
result.append('{').append(argumentNumbers[i]);
Format fmt = formats[i];
+ String subformatPattern = null;
if (fmt == null) {
// do nothing, string format
} else if (fmt instanceof NumberFormat) {
@@ -571,10 +577,12 @@ public class MessageFormat extends Format {
} else if (fmt.equals(NumberFormat.getIntegerInstance(locale))) {
result.append(",number,integer");
} else {
- if (fmt instanceof DecimalFormat) {
- result.append(",number,").append(((DecimalFormat)fmt).toPattern());
- } else if (fmt instanceof ChoiceFormat) {
- result.append(",choice,").append(((ChoiceFormat)fmt).toPattern());
+ if (fmt instanceof DecimalFormat dfmt) {
+ result.append(",number");
+ subformatPattern = dfmt.toPattern();
+ } else if (fmt instanceof ChoiceFormat cfmt) {
+ result.append(",choice");
+ subformatPattern = cfmt.toPattern();
} else {
// UNKNOWN
}
@@ -596,8 +604,9 @@ public class MessageFormat extends Format {
}
}
if (index >= DATE_TIME_MODIFIERS.length) {
- if (fmt instanceof SimpleDateFormat) {
- result.append(",date,").append(((SimpleDateFormat)fmt).toPattern());
+ if (fmt instanceof SimpleDateFormat sdfmt) {
+ result.append(",date");
+ subformatPattern = sdfmt.toPattern();
} else {
// UNKNOWN
}
@@ -607,6 +616,14 @@ public class MessageFormat extends Format {
} else {
//result.append(", unknown");
}
+ if (subformatPattern != null) {
+ result.append(',');
+
+ // The subformat pattern comes already quoted, but only for those characters that are
+ // special to the subformat. Therefore, we may need to quote additional characters.
+ // The ones we care about at the MessageFormat level are '{' and '}'.
+ copyAndQuoteBraces(subformatPattern, result);
+ }
result.append('}');
}
copyAndFixQuotes(pattern, lastOffset, pattern.length(), result);
@@ -1624,6 +1641,53 @@ public class MessageFormat extends Format {
}
}
+ // Copy the text, but add quotes around any quotables that aren't already quoted
+ private static void copyAndQuoteBraces(String source, StringBuilder target) {
+
+ // Analyze existing string for already quoted and newly quotable characters
+ record Qchar(char ch, boolean quoted) { };
+ ArrayList<Qchar> qchars = new ArrayList<>();
+ boolean quoted = false;
+ boolean anyChangeNeeded = false;
+ for (int i = 0; i < source.length(); i++) {
+ char ch = source.charAt(i);
+ if (ch == '\'') {
+ if (i + 1 < source.length() && source.charAt(i + 1) == '\'') {
+ qchars.add(new Qchar('\'', quoted));
+ i++;
+ } else {
+ quoted = !quoted;
+ }
+ } else {
+ boolean quotable = ch == '{' || ch == '}';
+ anyChangeNeeded |= quotable && !quoted;
+ qchars.add(new Qchar(ch, quoted || quotable));
+ }
+ }
+
+ // Was any change needed?
+ if (!anyChangeNeeded) {
+ target.append(source);
+ return;
+ }
+
+ // Build new string, automatically consolidating adjacent runs of quoted chars
+ quoted = false;
+ for (Qchar qchar : qchars) {
+ char ch = qchar.ch;
+ if (ch == '\'') {
+ target.append(ch); // doubling works whether quoted or not
+ } else if (qchar.quoted() != quoted) {
+ target.append('\'');
+ quoted = qchar.quoted();
+ }
+ target.append(ch);
+ }
+ if (quoted) {
+ target.append('\'');
+ }
+ }
+
/**
* After reading an object from the input stream, do a simple verification
* to maintain class invariants.
diff --git a/test/jdk/java/text/Format/MessageFormat/MessageFormatToPatternTest.java b/test/jdk/java/text/Format/MessageFormat/MessageFormatToPatternTest.java
new file mode 100644
index 000000000..020bc8033
--- /dev/null
+++ b/test/jdk/java/text/Format/MessageFormat/MessageFormatToPatternTest.java
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) 2024, 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
+ * @summary Verify that MessageFormat.toPattern() properly escapes special curly braces
+ * @bug 8323699
+ * @run junit MessageFormatToPatternTest
+ */
+
+import java.text.ChoiceFormat;
+import java.text.DateFormat;
+import java.text.DecimalFormat;
+import java.text.Format;
+import java.text.MessageFormat;
+import java.text.NumberFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Locale;
+import java.util.Random;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class MessageFormatToPatternTest {
+
+ private static final int NUM_RANDOM_TEST_CASES = 1000;
+
+ // Max levels of nesting of ChoiceFormats inside MessageFormats
+ private static final int MAX_FORMAT_NESTING = 3;
+
+ private static Locale savedLocale;
+ private static long randomSeed; // set this to a non-zero value for reproducibility
+ private static Random random;
+ private static boolean spitSeed;
+ private static int textCount;
+
+// Setup & Teardown
+
+ @BeforeAll
+ public static void setup() {
+ savedLocale = Locale.getDefault();
+ Locale.setDefault(Locale.US);
+ if (randomSeed == 0)
+ randomSeed = new Random().nextLong();
+ random = new Random(randomSeed);
+ }
+
+ @AfterAll
+ public static void teardown() {
+ Locale.setDefault(savedLocale);
+ }
+
+// Tests
+
+ // Test expected output when given a MessageFormat pattern string and value 1.23
+ @ParameterizedTest
+ @MethodSource("generateOutputTestCases")
+ public void testOutput(String pattern, String expected) {
+
+ // Test we get the expected output
+ MessageFormat format = new MessageFormat(pattern);
+ String actual = format.format(new Object[] { 1.23 });
+ assertEquals(expected, actual);
+
+ // Test round trip as well
+ testRoundTrip(format);
+ }
+
+ public static Stream<Arguments> generateOutputTestCases() {
+ return Stream.of(
+
+ // This is the test case from JDK-8323699
+ Arguments.of("{0,choice,0.0#option A: {0}|1.0#option B: {0}'}'}", "option B: 1.23}"),
+ Arguments.of("{0,choice,0.0#option A: {0}|2.0#option B: {0}'}'}", "option A: 1.23"),
+
+ // A few more test cases from the PR#17416 discussion
+ Arguments.of("Test: {0,number,foo'{'#.00}", "Test: foo{1.23"),
+ Arguments.of("Test: {0,number,foo'}'#.00}", "Test: foo}1.23"),
+ Arguments.of("{0,number,' abc }'' ' 0.00}", " abc }' 1.23"),
+ Arguments.of("Wayne ''The Great One'' Gretsky", "Wayne 'The Great One' Gretsky"),
+ Arguments.of("'Wayne ''The Great One'' Gretsky'", "Wayne 'The Great One' Gretsky"),
+ Arguments.of("{0,choice,0.0#'''{''curly''}'' braces'}", "{curly} braces"),
+ Arguments.of("{0,choice,0.0#''{''curly''}'' braces}", "{curly} braces"),
+ Arguments.of("{0,choice,0.0#'{0,choice,0.0#''{0,choice,0.0#''''{0,choice,0.0#foo}''''}''}'}", "foo"),
+
+ // Absurd double quote examples
+ Arguments.of("Foo '}''''''''}' {0,number,bar'}' '}' } baz ", "Foo }''''} bar} } 1 baz "),
+ Arguments.of("'''}''{'''}''''}'", "'}'{'}''}"),
+
+ // An absurdly complicated example
+ Arguments.of("{0,choice,0.0#text2887 [] '{'1,date,YYYY-MM-DD'}' text2888 [''*'']|1.0#found|2.0#'text2901 [oog'')!''] {2,choice,0.0#''text2897 ['''']''''wq1Q] {2,choice,0.0#''''text2891 [s''''''''&''''''''] {0,number,#0.##} text2892 [8''''''''|$'''''''''''''''''''''''']''''|1.0#''''text2893 [] {0,number,#0.##} text2894 [S'''''''']'''''''']''''|2.0#text2895 [''''''''.''''''''eB] {1,date,YYYY-MM-DD} text2896 [9Y]} text2898 []''|1.0#''text2899 [xk7] {0,number,#0.##} text2900 []''} text2902 [7'':$)''O]'}{0,choice,0.0#'text2903 [] {0,number,#0.##} text2904 [S'':'']'|1.0#'me'}", "foundme")
+ );
+ }
+
+ // Go roundrip from MessageFormat -> pattern string -> MessageFormat and verify equivalence
+ @ParameterizedTest
+ @MethodSource("generateRoundTripTestCases")
+ public void testRoundTrip(MessageFormat format1) {
+
+ // Prepare MessageFormat argument
+ Object[] args = new Object[] {
+ 8.5, // argument for DecimalFormat
+ new Date(1705502102677L), // argument for SimpleDateFormat
+ random.nextInt(6) // argument for ChoiceFormat
+ };
+
+ String pattern1 = null;
+ String result1 = null;
+ String pattern2 = null;
+ String result2 = null;
+ try {
+
+ // Format using the given MessageFormat
+ pattern1 = format1.toPattern();
+ result1 = format1.format(args);
+
+ // Round-trip via toPattern() and repeat
+ MessageFormat format2 = new MessageFormat(pattern1);
+ pattern2 = format2.toPattern();
+ result2 = format2.format(args);
+
+ // Check equivalence
+ assertEquals(result1, result2);
+ assertEquals(pattern1, pattern2);
+
+ // Debug
+ //showRoundTrip(format1, pattern1, result1, pattern2, result2);
+ } catch (RuntimeException | Error e) {
+ System.out.println(String.format("%n********** FAILURE **********%n"));
+ System.out.println(String.format("%s%n", e));
+ if (!spitSeed) {
+ System.out.println(String.format("*** Random seed was 0x%016xL%n", randomSeed));
+ spitSeed = true;
+ }
+ showRoundTrip(format1, pattern1, result1, pattern2, result2);
+ throw e;
+ }
+ }
+
+ public static Stream<Arguments> generateRoundTripTestCases() {
+ final ArrayList<Arguments> argList = new ArrayList<>();
+ for (int i = 0; i < NUM_RANDOM_TEST_CASES; i++)
+ argList.add(Arguments.of(randomFormat()));
+ return argList.stream();
+ }
+
+ // Generate a "random" MessageFormat. We do this by creating a MessageFormat with "{0}" placeholders
+ // and then substituting in random DecimalFormat, DateFormat, and ChoiceFormat subformats. The goal here
+ // is to avoid using pattern strings to construct formats, because they're what we're trying to check.
+ private static MessageFormat randomFormat() {
+
+ // Create a temporary MessageFormat containing "{0}" placeholders and random text
+ StringBuilder tempPattern = new StringBuilder();
+ int numParts = random.nextInt(3) + 1;
+ for (int i = 0; i < numParts; i++) {
+ if (random.nextBoolean())
+ tempPattern.append("{0}"); // temporary placeholder for a subformat
+ else
+ tempPattern.append(quoteText(randomText()));
+ }
+
+ // Replace all the "{0}" placeholders with random subformats
+ MessageFormat format = new MessageFormat(tempPattern.toString());
+ Format[] formats = format.getFormats();
+ for (int i = 0; i < formats.length; i++)
+ formats[i] = randomSubFormat(0);
+ format.setFormats(formats);
+
+ // Done
+ return format;
+ }
+
+ // Generate some random text
+ private static String randomText() {
+ StringBuilder buf = new StringBuilder();
+ int length = random.nextInt(6);
+ for (int i = 0; i < length; i++) {
+ char ch = (char)(0x20 + random.nextInt(0x5f));
+ buf.append(ch);
+ }
+ return buf.toString();
+ }
+
+ // Quote non-alphanumeric characters in the given plain text
+ private static String quoteText(String string) {
+ StringBuilder buf = new StringBuilder();
+ boolean quoted = false;
+ for (int i = 0; i < string.length(); i++) {
+ char ch = string.charAt(i);
+ if (ch == '\'')
+ buf.append("''");
+ else if (!(ch == ' ' || Character.isLetter(ch) || Character.isDigit(ch))) {
+ if (!quoted) {
+ buf.append('\'');
+ quoted = true;
+ }
+ buf.append(ch);
+ } else {
+ if (quoted) {
+ buf.append('\'');
+ quoted = false;
+ }
+ buf.append(ch);
+ }
+ }
+ if (quoted)
+ buf.append('\'');
+ return buf.toString();
+ }
+
+ // Create a random subformat for a MessageFormat
+ private static Format randomSubFormat(int nesting) {
+ int which;
+ if (nesting >= MAX_FORMAT_NESTING)
+ which = random.nextInt(2); // no more recursion
+ else
+ which = random.nextInt(3);
+ switch (which) {
+ case 0:
+ return new DecimalFormat("#.##");
+ case 1:
+ return new SimpleDateFormat("YYYY-MM-DD");
+ default:
+ int numChoices = random.nextInt(3) + 1;
+ assert numChoices > 0;
+ final double[] limits = new double[numChoices];
+ final String[] formats = new String[numChoices];
+ for (int i = 0; i < limits.length; i++) {
+ limits[i] = (double)i;
+ formats[i] = randomMessageFormatContaining(randomSubFormat(nesting + 1));
+ }
+ return new ChoiceFormat(limits, formats);
+ }
+ }
+
+ // Create a MessageFormat pattern string that includes the given Format as a subformat.
+ // The result will be one option in a ChoiceFormat which is nested in an outer MessageFormat.
+ // A ChoiceFormat option string is just a plain string; it's only when that plain string
+ // bubbles up to a containing MessageFormat that it gets interpreted as a MessageFormat string,
+ // and that only happens if the option string contains a '{' character. That will always
+ // be the case for the strings returned by this method of course.
+ private static String randomMessageFormatContaining(Format format) {
+ String beforeText = quoteText(randomText().replaceAll("\\{", "")); // avoid invalid MessageFormat syntax
+ String afterText = quoteText(randomText().replaceAll("\\{", "")); // avoid invalid MessageFormat syntax
+ String middleText;
+ if (format instanceof DecimalFormat dfmt)
+ middleText = String.format("{0,number,%s}", dfmt.toPattern());
+ else if (format instanceof SimpleDateFormat sdfmt)
+ middleText = String.format("{1,date,%s}", sdfmt.toPattern());
+ else if (format instanceof ChoiceFormat cfmt)
+ middleText = String.format("{2,choice,%s}", cfmt.toPattern());
+ else
+ throw new RuntimeException("internal error");
+ return String.format("text%d [%s] %s text%d [%s]", ++textCount, beforeText, middleText, ++textCount, afterText);
+ }
+
+// Debug printing
+
+ private void showRoundTrip(MessageFormat format1, String pattern1, String result1, String pattern2, String result2) {
+ print(0, format1);
+ System.out.println();
+ if (pattern1 != null)
+ System.out.println(String.format(" pattern1 = %s", javaLiteral(pattern1)));
+ if (result1 != null)
+ System.out.println(String.format(" result1 = %s", javaLiteral(result1)));
+ if (pattern2 != null)
+ System.out.println(String.format(" pattern2 = %s", javaLiteral(pattern2)));
+ if (result2 != null)
+ System.out.println(String.format(" result2 = %s", javaLiteral(result2)));
+ System.out.println();
+ }
+
+ private static void print(int depth, Object format) {
+ if (format == null)
+ return;
+ if (format instanceof String)
+ System.out.println(String.format("%s- %s", indent(depth), javaLiteral((String)format)));
+ else if (format instanceof MessageFormat)
+ print(depth, (MessageFormat)format);
+ else if (format instanceof DecimalFormat)
+ print(depth, (DecimalFormat)format);
+ else if (format instanceof SimpleDateFormat)
+ print(depth, (SimpleDateFormat)format);
+ else if (format instanceof ChoiceFormat)
+ print(depth, (ChoiceFormat)format);
+ else
+ throw new RuntimeException("internal error: " + format.getClass());
+ }
+
+ private static void print(int depth, MessageFormat format) {
+ System.out.println(String.format("%s- %s: %s", indent(depth), "MessageFormat", javaLiteral(format.toPattern())));
+ for (Format subformat : format.getFormats())
+ print(depth + 1, subformat);
+ }
+
+ private static void print(int depth, DecimalFormat format) {
+ System.out.println(String.format("%s- %s: %s", indent(depth), "DecimalFormat", javaLiteral(format.toPattern())));
+ }
+
+ private static void print(int depth, SimpleDateFormat format) {
+ System.out.println(String.format("%s- %s: %s", indent(depth), "SimpleDateFormat", javaLiteral(format.toPattern())));
+ }
+
+ private static void print(int depth, ChoiceFormat format) {
+ System.out.println(String.format("%s- %s: %s", indent(depth), "ChoiceFormat", javaLiteral(format.toPattern())));
+ for (Object subformat : format.getFormats())
+ print(depth + 1, subformat);
+ }
+
+ private static String indent(int depth) {
+ StringBuilder buf = new StringBuilder();
+ for (int i = 0; i < depth; i++)
+ buf.append(" ");
+ return buf.toString();
+ }
+
+ // Print a Java string in double quotes so it looks like a String literal (for easy pasting into jshell)
+ private static String javaLiteral(String string) {
+ StringBuilder buf = new StringBuilder();
+ buf.append('"');
+ for (int i = 0; i < string.length(); i++) {
+ char ch = string.charAt(i);
+ switch (ch) {
+ case '"':
+ case '\\':
+ buf.append('\\');
+ // FALLTHROUGH
+ default:
+ buf.append(ch);
+ break;
+ }
+ }
+ return buf.append('"').toString();
+ }
+}
diff --git a/test/jdk/java/text/Format/MessageFormat/MessageFormatsByArgumentIndex.java b/test/jdk/java/text/Format/MessageFormat/MessageFormatsByArgumentIndex.java
index 1d69258f6..b82d566d3 100644
--- a/test/jdk/java/text/Format/MessageFormat/MessageFormatsByArgumentIndex.java
+++ b/test/jdk/java/text/Format/MessageFormat/MessageFormatsByArgumentIndex.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2024, 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
@@ -35,6 +35,7 @@ import java.text.NumberFormat;
public class MessageFormatsByArgumentIndex {
private static String choicePattern = "0.0#are no files|1.0#is one file|1.0<are {0,number,integer} files";
+ private static String quotedChoicePattern = choicePattern.replaceAll("([{}])", "'$1'");
public static void main(String[] args) {
Format[] subformats;
@@ -56,7 +57,7 @@ public class MessageFormatsByArgumentIndex {
format.setFormatByArgumentIndex(0, NumberFormat.getInstance());
- checkPattern(format.toPattern(), "{3,choice," + choicePattern + "}, {2}, {0,number}");
+ checkPattern(format.toPattern(), "{3,choice," + quotedChoicePattern + "}, {2}, {0,number}");
subformats = format.getFormatsByArgumentIndex();
checkSubformatLength(subformats, 4);
@@ -73,7 +74,8 @@ public class MessageFormatsByArgumentIndex {
format.setFormatsByArgumentIndex(subformats);
- checkPattern(format.toPattern(), "{3,choice," + choicePattern + "}, {2,number}, {0,choice," + choicePattern + "}");
+ checkPattern(format.toPattern(),
+ "{3,choice," + quotedChoicePattern + "}, {2,number}, {0,choice," + quotedChoicePattern + "}");
subformats = format.getFormatsByArgumentIndex();
checkSubformatLength(subformats, 4);
diff --git a/test/jdk/java/text/Format/MessageFormat/MessageRegression.java b/test/jdk/java/text/Format/MessageFormat/MessageRegression.java
index 344888f47..e10e48992 100644
--- a/test/jdk/java/text/Format/MessageFormat/MessageRegression.java
+++ b/test/jdk/java/text/Format/MessageFormat/MessageRegression.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2024, 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
@@ -114,9 +114,9 @@ public class MessageRegression {
@Test
public void Test4058973() {
- MessageFormat fmt = new MessageFormat("{0,choice,0#no files|1#one file|1< {0,number,integer} files}");
+ MessageFormat fmt = new MessageFormat("{0,choice,0.0#no files|1.0#one file|1.0< '{'0,number,integer'}' files}");
String pat = fmt.toPattern();
- if (!pat.equals("{0,choice,0.0#no files|1.0#one file|1.0< {0,number,integer} files}")) {
+ if (!pat.equals("{0,choice,0.0#no files|1.0#one file|1.0< '{'0,number,integer'}' files}")) {
fail("MessageFormat.toPattern failed");
}
}
--
2.33.0