mirror of
https://github.com/openjdk/jdk.git
synced 2026-01-28 12:09:14 +00:00
8363972: Lenient parsing of minus sign pattern in DecimalFormat/CompactNumberFormat
Reviewed-by: jlu, rriggs
This commit is contained in:
Naoto Sato
parent
b426151a33
commit
23670fd418
@ -79,6 +79,7 @@ class Bundle {
|
||||
"NumberElements/nan",
|
||||
"NumberElements/currencyDecimal",
|
||||
"NumberElements/currencyGroup",
|
||||
"NumberElements/lenientMinusSigns",
|
||||
};
|
||||
|
||||
private static final String[] TIME_PATTERN_KEYS = {
|
||||
|
||||
@ -844,6 +844,26 @@ class LDMLParseHandler extends AbstractLDMLHandler<Object> {
|
||||
});
|
||||
break;
|
||||
|
||||
// Lenient parsing
|
||||
case "parseLenients":
|
||||
if ("lenient".equals(attributes.getValue("level"))) {
|
||||
pushKeyContainer(qName, attributes, attributes.getValue("scope"));
|
||||
} else {
|
||||
pushIgnoredContainer(qName);
|
||||
}
|
||||
break;
|
||||
|
||||
case "parseLenient":
|
||||
// Use only the lenient minus sign for now
|
||||
if (currentContainer instanceof KeyContainer kc
|
||||
&& kc.getKey().equals("number")
|
||||
&& attributes.getValue("sample").equals("-")) {
|
||||
pushStringEntry(qName, attributes, currentNumberingSystem + "NumberElements/lenientMinusSigns");
|
||||
} else {
|
||||
pushIgnoredContainer(qName);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
// treat anything else as a container
|
||||
pushContainer(qName, attributes);
|
||||
@ -1150,6 +1170,14 @@ class LDMLParseHandler extends AbstractLDMLHandler<Object> {
|
||||
currentStyle = "";
|
||||
putIfEntry();
|
||||
break;
|
||||
case "parseLenient":
|
||||
if (currentContainer instanceof StringEntry se) {
|
||||
// Convert to a simple concatenation of lenient minuses
|
||||
// e.g. "[\-－﹣ ‐‑ ‒ – −⁻₋ ➖]" -> "-－﹣‐‑‒–−⁻₋➖" for the root locale
|
||||
put(se.getKey(), se.getValue().replaceAll("[\\[\\]\\\\ ]", ""));
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
putIfEntry();
|
||||
}
|
||||
|
||||
@ -147,7 +147,7 @@ import java.util.stream.Collectors;
|
||||
* a compact pattern. This special pattern can appear explicitly for any specific
|
||||
* range, or considered as a default pattern for an empty string.
|
||||
*
|
||||
* <h3>Negative Subpatterns</h3>
|
||||
* <h3><a id="negative_subpatterns">Negative Subpatterns</a></h3>
|
||||
* A compact pattern contains a positive and negative subpattern
|
||||
* separated by a subpattern boundary character {@code ';'},
|
||||
* for example, {@code "0K;-0K"}. Each subpattern has a prefix,
|
||||
@ -159,7 +159,10 @@ import java.util.stream.Collectors;
|
||||
* the negative prefix and suffix. The number of minimum integer digits,
|
||||
* and other characteristics are all the same as the positive pattern.
|
||||
* That means that {@code "0K;-00K"} produces precisely the same behavior
|
||||
* as {@code "0K;-0K"}.
|
||||
* as {@code "0K;-0K"}. In {@link NumberFormat##leniency lenient parsing}
|
||||
* mode, loose matching of the minus sign pattern is enabled, following the
|
||||
* LDML’s <a href="https://unicode.org/reports/tr35/#Loose_Matching">
|
||||
* loose matching</a> specification.
|
||||
*
|
||||
* <h4>Escaping Special Characters</h4>
|
||||
* Many characters in a compact pattern are taken literally, they are matched
|
||||
@ -1585,6 +1588,9 @@ public final class CompactNumberFormat extends NumberFormat {
|
||||
* and are not digits that occur within the numerical portion
|
||||
* </ul>
|
||||
* <p>
|
||||
* When lenient, the minus sign in the {@link ##negative_subpatterns
|
||||
* negative subpatterns} is loosely matched against lenient minus sign characters.
|
||||
* <p>
|
||||
* The subclass returned depends on the value of
|
||||
* {@link #isParseBigDecimal}.
|
||||
* <ul>
|
||||
@ -1693,14 +1699,12 @@ public final class CompactNumberFormat extends NumberFormat {
|
||||
// Given text does not match the non empty valid compact prefixes
|
||||
// check with the default prefixes
|
||||
if (!gotPositive && !gotNegative) {
|
||||
if (text.regionMatches(pos.index, defaultPosPrefix, 0,
|
||||
defaultPosPrefix.length())) {
|
||||
if (decimalFormat.matchAffix(text, position, defaultPosPrefix)) {
|
||||
// Matches the default positive prefix
|
||||
matchedPosPrefix = defaultPosPrefix;
|
||||
gotPositive = true;
|
||||
}
|
||||
if (text.regionMatches(pos.index, defaultNegPrefix, 0,
|
||||
defaultNegPrefix.length())) {
|
||||
if (decimalFormat.matchAffix(text, position, defaultNegPrefix)) {
|
||||
// Matches the default negative prefix
|
||||
matchedNegPrefix = defaultNegPrefix;
|
||||
gotNegative = true;
|
||||
@ -1924,7 +1928,7 @@ public final class CompactNumberFormat extends NumberFormat {
|
||||
if (!affix.isEmpty() && !affix.equals(defaultAffix)) {
|
||||
// Look ahead only for the longer match than the previous match
|
||||
if (matchedAffix.length() < affix.length()) {
|
||||
return text.regionMatches(position, affix, 0, affix.length());
|
||||
return decimalFormat.matchAffix(text, position, affix);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
@ -2026,8 +2030,7 @@ public final class CompactNumberFormat extends NumberFormat {
|
||||
if (!gotPos && !gotNeg) {
|
||||
String positiveSuffix = defaultDecimalFormat.getPositiveSuffix();
|
||||
String negativeSuffix = defaultDecimalFormat.getNegativeSuffix();
|
||||
boolean containsPosSuffix = text.regionMatches(position,
|
||||
positiveSuffix, 0, positiveSuffix.length());
|
||||
boolean containsPosSuffix = decimalFormat.matchAffix(text, position, positiveSuffix);
|
||||
boolean endsWithPosSuffix = containsPosSuffix && text.length() ==
|
||||
position + positiveSuffix.length();
|
||||
if (parseStrict ? endsWithPosSuffix : containsPosSuffix) {
|
||||
@ -2035,8 +2038,7 @@ public final class CompactNumberFormat extends NumberFormat {
|
||||
matchedPosSuffix = positiveSuffix;
|
||||
gotPos = true;
|
||||
}
|
||||
boolean containsNegSuffix = text.regionMatches(position,
|
||||
negativeSuffix, 0, negativeSuffix.length());
|
||||
boolean containsNegSuffix = decimalFormat.matchAffix(text, position, negativeSuffix);
|
||||
boolean endsWithNegSuffix = containsNegSuffix && text.length() ==
|
||||
position + negativeSuffix.length();
|
||||
if (parseStrict ? endsWithNegSuffix : containsNegSuffix) {
|
||||
|
||||
@ -296,7 +296,7 @@ import sun.util.locale.provider.ResourceBundleBasedAdapter;
|
||||
* #setMaximumIntegerDigits(int)} can be used to manually adjust the maximum
|
||||
* integer digits.
|
||||
*
|
||||
* <h3>Negative Subpatterns</h3>
|
||||
* <h3><a id="negative_subpatterns">Negative Subpatterns</a></h3>
|
||||
* A {@code DecimalFormat} pattern contains a positive and negative
|
||||
* subpattern, for example, {@code "#,##0.00;(#,##0.00)"}. Each
|
||||
* subpattern has a prefix, numeric part, and suffix. The negative subpattern
|
||||
@ -307,7 +307,11 @@ import sun.util.locale.provider.ResourceBundleBasedAdapter;
|
||||
* serves only to specify the negative prefix and suffix; the number of digits,
|
||||
* minimal digits, and other characteristics are all the same as the positive
|
||||
* pattern. That means that {@code "#,##0.0#;(#)"} produces precisely
|
||||
* the same behavior as {@code "#,##0.0#;(#,##0.0#)"}.
|
||||
* the same behavior as {@code "#,##0.0#;(#,##0.0#)"}. In
|
||||
* {@link NumberFormat##leniency lenient parsing} mode, loose matching of the
|
||||
* minus sign pattern is enabled, following the LDML’s
|
||||
* <a href="https://unicode.org/reports/tr35/#Loose_Matching">
|
||||
* loose matching</a> specification.
|
||||
*
|
||||
* <p>The prefixes, suffixes, and various symbols used for infinity, digits,
|
||||
* grouping separators, decimal separators, etc. may be set to arbitrary
|
||||
@ -2189,6 +2193,9 @@ public class DecimalFormat extends NumberFormat {
|
||||
* and are not digits that occur within the numerical portion
|
||||
* </ul>
|
||||
* <p>
|
||||
* When lenient, the minus sign in the {@link ##negative_subpatterns
|
||||
* negative subpatterns} is loosely matched against lenient minus sign characters.
|
||||
* <p>
|
||||
* The subclass returned depends on the value of {@link #isParseBigDecimal}
|
||||
* as well as on the string being parsed.
|
||||
* <ul>
|
||||
@ -2385,10 +2392,8 @@ public class DecimalFormat extends NumberFormat {
|
||||
boolean gotPositive, gotNegative;
|
||||
|
||||
// check for positivePrefix; take longest
|
||||
gotPositive = text.regionMatches(position, positivePrefix, 0,
|
||||
positivePrefix.length());
|
||||
gotNegative = text.regionMatches(position, negativePrefix, 0,
|
||||
negativePrefix.length());
|
||||
gotPositive = matchAffix(text, position, positivePrefix);
|
||||
gotNegative = matchAffix(text, position, negativePrefix);
|
||||
|
||||
if (gotPositive && gotNegative) {
|
||||
if (positivePrefix.length() > negativePrefix.length()) {
|
||||
@ -2424,15 +2429,13 @@ public class DecimalFormat extends NumberFormat {
|
||||
// When lenient, text only needs to contain the suffix.
|
||||
if (!isExponent) {
|
||||
if (gotPositive) {
|
||||
boolean containsPosSuffix =
|
||||
text.regionMatches(position, positiveSuffix, 0, positiveSuffix.length());
|
||||
boolean containsPosSuffix = matchAffix(text, position, positiveSuffix);
|
||||
boolean endsWithPosSuffix =
|
||||
containsPosSuffix && text.length() == position + positiveSuffix.length();
|
||||
gotPositive = parseStrict ? endsWithPosSuffix : containsPosSuffix;
|
||||
}
|
||||
if (gotNegative) {
|
||||
boolean containsNegSuffix =
|
||||
text.regionMatches(position, negativeSuffix, 0, negativeSuffix.length());
|
||||
boolean containsNegSuffix = matchAffix(text, position, negativeSuffix);
|
||||
boolean endsWithNegSuffix =
|
||||
containsNegSuffix && text.length() == position + negativeSuffix.length();
|
||||
gotNegative = parseStrict ? endsWithNegSuffix : containsNegSuffix;
|
||||
@ -3501,6 +3504,54 @@ public class DecimalFormat extends NumberFormat {
|
||||
if (needQuote) buffer.append('\'');
|
||||
}
|
||||
|
||||
/**
|
||||
* {@return true if the text matches the affix}
|
||||
* In lenient mode, lenient minus signs also match the hyphen-minus
|
||||
* (U+002D). Package-private access, as this is called from
|
||||
* CompactNumberFormat.
|
||||
*
|
||||
* Note: Minus signs in the supplementary character range or normalization
|
||||
* equivalents are not matched, as they may alter the affix length.
|
||||
*/
|
||||
boolean matchAffix(String text, int position, String affix) {
|
||||
var alen = affix.length();
|
||||
var tlen = text.length();
|
||||
|
||||
if (alen == 0) {
|
||||
// always match with an empty affix, as affix is optional
|
||||
return true;
|
||||
}
|
||||
if (position >= tlen) {
|
||||
return false;
|
||||
}
|
||||
if (parseStrict) {
|
||||
return text.regionMatches(position, affix, 0, alen);
|
||||
}
|
||||
|
||||
var lms = symbols.getLenientMinusSigns();
|
||||
int i = 0;
|
||||
int limit = Math.min(tlen, position + alen);
|
||||
for (; position + i < limit; i++) {
|
||||
char t = text.charAt(position + i);
|
||||
char a = affix.charAt(i);
|
||||
int tIndex = lms.indexOf(t);
|
||||
int aIndex = lms.indexOf(a);
|
||||
// Non LMS. Match direct
|
||||
if (tIndex < 0 && aIndex < 0) {
|
||||
if (t != a) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
// By here, at least one LMS. Ensure both LMS.
|
||||
if (tIndex < 0 || aIndex < 0) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Return true if entire affix was matched
|
||||
return i == alen;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of producing a pattern. This method returns a positive and
|
||||
* negative (if needed), pattern string in the form of : Prefix (optional)
|
||||
|
||||
@ -718,6 +718,17 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
|
||||
this.minusSign = findNonFormatChar(minusSignText, '-');
|
||||
}
|
||||
|
||||
/**
|
||||
* {@return the lenient minus signs} Multiple lenient minus signs
|
||||
* are concatenated to form the returned string. Each codepoint
|
||||
* in the string is a valid minus sign pattern. If there are no
|
||||
* lenient minus signs defined in this locale, {@code minusSignText}
|
||||
* is returned.
|
||||
*/
|
||||
String getLenientMinusSigns() {
|
||||
return lenientMinusSigns;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------
|
||||
// END Package Private methods ... to be made public later
|
||||
//------------------------------------------------------------
|
||||
@ -818,18 +829,7 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
|
||||
private void initialize(Locale locale) {
|
||||
this.locale = locale;
|
||||
|
||||
// check for region override
|
||||
Locale override = locale.getUnicodeLocaleType("nu") == null ?
|
||||
CalendarDataUtility.findRegionOverride(locale) :
|
||||
locale;
|
||||
|
||||
// get resource bundle data
|
||||
LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(DecimalFormatSymbolsProvider.class, override);
|
||||
// Avoid potential recursions
|
||||
if (!(adapter instanceof ResourceBundleBasedAdapter)) {
|
||||
adapter = LocaleProviderAdapter.getResourceBundleBased();
|
||||
}
|
||||
Object[] data = adapter.getLocaleResources(override).getDecimalFormatSymbolsData();
|
||||
Object[] data = loadNumberData(locale);
|
||||
String[] numberElements = (String[]) data[0];
|
||||
|
||||
decimalSeparator = numberElements[0].charAt(0);
|
||||
@ -854,11 +854,30 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
|
||||
monetaryGroupingSeparator = numberElements.length < 13 || numberElements[12].isEmpty() ?
|
||||
groupingSeparator : numberElements[12].charAt(0);
|
||||
|
||||
// Lenient minus signs
|
||||
lenientMinusSigns = numberElements.length < 14 ? minusSignText : numberElements[13];
|
||||
|
||||
// maybe filled with previously cached values, or null.
|
||||
intlCurrencySymbol = (String) data[1];
|
||||
currencySymbol = (String) data[2];
|
||||
}
|
||||
|
||||
private Object[] loadNumberData(Locale locale) {
|
||||
// check for region override
|
||||
Locale override = locale.getUnicodeLocaleType("nu") == null ?
|
||||
CalendarDataUtility.findRegionOverride(locale) :
|
||||
locale;
|
||||
|
||||
// get resource bundle data
|
||||
LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(DecimalFormatSymbolsProvider.class, override);
|
||||
// Avoid potential recursions
|
||||
if (!(adapter instanceof ResourceBundleBasedAdapter)) {
|
||||
adapter = LocaleProviderAdapter.getResourceBundleBased();
|
||||
}
|
||||
|
||||
return adapter.getLocaleResources(override).getDecimalFormatSymbolsData();
|
||||
}
|
||||
|
||||
/**
|
||||
* Obtains non-format single character from String
|
||||
*/
|
||||
@ -995,6 +1014,14 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
|
||||
}
|
||||
currencyInitialized = true;
|
||||
}
|
||||
|
||||
if (loadNumberData(locale) instanceof Object[] d &&
|
||||
d[0] instanceof String[] numberElements &&
|
||||
numberElements.length >= 14) {
|
||||
lenientMinusSigns = numberElements[13];
|
||||
} else {
|
||||
lenientMinusSigns = minusSignText;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1174,6 +1201,9 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
|
||||
private transient Currency currency;
|
||||
private transient volatile boolean currencyInitialized;
|
||||
|
||||
// Lenient minus. No need to be set by applications
|
||||
private transient String lenientMinusSigns;
|
||||
|
||||
/**
|
||||
* Cached hash code.
|
||||
*/
|
||||
|
||||
@ -195,7 +195,11 @@ import sun.util.locale.provider.LocaleServiceProviderPool;
|
||||
* Lenient parsing should be used when attempting to parse a number
|
||||
* out of a String that contains non-numerical or non-format related values.
|
||||
* For example, using a {@link Locale#US} currency format to parse the number
|
||||
* {@code 1000} out of the String "$1,000.00 was paid".
|
||||
* {@code 1000} out of the String "$1,000.00 was paid". Lenient parsing also
|
||||
* allows loose matching of characters in the source text. For example, an
|
||||
* implementation of the {@code NumberFormat} class may allow matching "−"
|
||||
* (U+2212 MINUS SIGN) to the "-" (U+002D HYPHEN-MINUS) pattern character
|
||||
* when used as a negative prefix.
|
||||
* <p>
|
||||
* Strict parsing should be used when attempting to ensure a String adheres exactly
|
||||
* to a locale's conventions, and can thus serve to validate input. For example, successfully
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2018, 2025, 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
|
||||
@ -22,7 +22,7 @@
|
||||
*/
|
||||
/*
|
||||
* @test
|
||||
* @bug 8177552 8217721 8222756 8295372 8306116 8319990 8338690
|
||||
* @bug 8177552 8217721 8222756 8295372 8306116 8319990 8338690 8363972
|
||||
* @summary Checks the functioning of compact number format
|
||||
* @modules jdk.localedata
|
||||
* @run testng/othervm TestCompactNumber
|
||||
@ -462,6 +462,8 @@ public class TestCompactNumber {
|
||||
{FORMAT_SE_SHORT, "12345679,89\u00a0bn", 1.2345679890000001E19, Double.class},
|
||||
{FORMAT_SE_SHORT, "\u2212999", -999L, Long.class},
|
||||
{FORMAT_SE_SHORT, "\u22128\u00a0mn", -8000000L, Long.class},
|
||||
// lenient parsing. Hyphen-minus should match the localized minus sign
|
||||
{FORMAT_SE_SHORT, "-8\u00a0mn", -8000000L, Long.class},
|
||||
{FORMAT_SE_SHORT, "\u22128\u00a0dt", -8000L, Long.class},
|
||||
{FORMAT_SE_SHORT, "\u221212345679\u00a0bn", -1.2345679E19, Double.class},
|
||||
{FORMAT_SE_SHORT, "\u221212345679,89\u00a0bn", -1.2345679890000001E19, Double.class},
|
||||
@ -503,8 +505,7 @@ public class TestCompactNumber {
|
||||
{FORMAT_EN_US_SHORT, "K12,347", null},
|
||||
// Invalid prefix for ja_JP
|
||||
{FORMAT_JA_JP_SHORT, "\u4E071", null},
|
||||
// Localized minus sign should be used
|
||||
{FORMAT_SE_SHORT, "-8\u00a0mn", null},};
|
||||
};
|
||||
}
|
||||
|
||||
@DataProvider(name = "invalidParse")
|
||||
|
||||
251
test/jdk/java/text/Format/NumberFormat/LenientMinusSignTest.java
Normal file
251
test/jdk/java/text/Format/NumberFormat/LenientMinusSignTest.java
Normal file
@ -0,0 +1,251 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8363972
|
||||
* @summary Unit tests for lenient minus parsing
|
||||
* @modules jdk.localedata
|
||||
* java.base/java.text:+open
|
||||
* @run junit LenientMinusSignTest
|
||||
*/
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.lang.invoke.MethodHandles;
|
||||
import java.text.CompactNumberFormat;
|
||||
import java.text.DecimalFormat;
|
||||
import java.text.DecimalFormatSymbols;
|
||||
import java.text.NumberFormat;
|
||||
import java.text.ParseException;
|
||||
import java.util.Locale;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import org.junit.jupiter.api.Nested;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.MethodSource;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
|
||||
public class LenientMinusSignTest {
|
||||
private static final Locale FINNISH = Locale.of("fi");
|
||||
private static final DecimalFormatSymbols DFS =
|
||||
new DecimalFormatSymbols(Locale.ROOT);
|
||||
private static final String MINUS_PATTERN = "\u002D";
|
||||
|
||||
// "parseLenient" data from CLDR v47. These data are subject to change
|
||||
private static Stream<String> minus() {
|
||||
return Stream.of(
|
||||
MINUS_PATTERN, // "-" Hyphen-Minus
|
||||
"\uFF0D", // "－" Fullwidth Hyphen-Minus
|
||||
"\uFE63", // "﹣" Small Hyphen-Minus
|
||||
"\u2010", // "‐" Hyphen
|
||||
"\u2011", // "‑" Non-Breaking Hyphen
|
||||
"\u2012", // "‒" Figure Dash
|
||||
"\u2013", // "–" En Dash
|
||||
"\u2212", // "−" Minus Sign
|
||||
"\u207B", // "⁻" Superscript Minus
|
||||
"\u208B", // "₋" Subscript Minus
|
||||
"\u2796" // "➖" Heavy Minus Sign
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFinnishMinus() throws ParseException {
|
||||
// originally reported in JDK-8189097
|
||||
// Should not throw a ParseException
|
||||
assertEquals(NumberFormat.getInstance(FINNISH).parse(MINUS_PATTERN + "1,5"), -1.5);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFinnishMinusStrict() {
|
||||
// Should throw a ParseException
|
||||
var nf = NumberFormat.getInstance(FINNISH);
|
||||
nf.setStrict(true);
|
||||
assertThrows(ParseException.class, () -> nf.parse(MINUS_PATTERN + "1,5"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testReadObject() throws IOException, ClassNotFoundException, ParseException {
|
||||
// check if deserialized NF works with lenient minus. Using the Finnish example
|
||||
var nf = NumberFormat.getInstance(FINNISH);
|
||||
NumberFormat nfDeser;
|
||||
byte[] serialized;
|
||||
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
ObjectOutputStream out = new ObjectOutputStream(bos)) {
|
||||
out.writeObject(nf);
|
||||
out.flush();
|
||||
serialized = bos.toByteArray();
|
||||
}
|
||||
try (ByteArrayInputStream bis = new ByteArrayInputStream(serialized);
|
||||
ObjectInputStream in = new ObjectInputStream(bis)) {
|
||||
nfDeser = (NumberFormat) in.readObject();
|
||||
}
|
||||
assertEquals(nfDeser.parse(MINUS_PATTERN + "1,5"), -1.5);
|
||||
}
|
||||
|
||||
// White box test. modifies the private `lenientMinusSigns` field in the DFS
|
||||
@Test
|
||||
void testSupplementary() throws IllegalAccessException, NoSuchFieldException, ParseException {
|
||||
var dfs = new DecimalFormatSymbols(Locale.ROOT);
|
||||
MethodHandles.privateLookupIn(DecimalFormatSymbols.class, MethodHandles.lookup())
|
||||
.findVarHandle(DecimalFormatSymbols.class, "lenientMinusSigns", String.class)
|
||||
.set(dfs, "-🙂");
|
||||
// Direct match. Should succeed
|
||||
var df = new DecimalFormat("#.#;🙂#.#", dfs);
|
||||
assertEquals(df.parse("🙂1.5"), -1.5);
|
||||
|
||||
// Fail if the lengths of negative prefixes differ
|
||||
assertThrows(ParseException.class, () -> df.parse("-1.5"));
|
||||
var df2= new DecimalFormat("#.#;-#.#", dfs);
|
||||
assertThrows(ParseException.class, () -> df2.parse("🙂1.5"));
|
||||
}
|
||||
|
||||
@Nested
|
||||
class DecimalFormatTest {
|
||||
private static final String PREFIX = "+#;-#";
|
||||
private static final String SUFFIX = "#+;#-";
|
||||
private static final String LONG_PREFIX = "pos#;-neg#";
|
||||
private static final String LONG_SUFFIX = "#pos;#neg-";
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLenientPrefix(String sign) throws ParseException {
|
||||
var df = new DecimalFormat(PREFIX, DFS);
|
||||
df.setStrict(false);
|
||||
assertEquals(MINUS_PATTERN + "1", df.format(df.parse(sign + "1")));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLenientSuffix(String sign) throws ParseException {
|
||||
var df = new DecimalFormat(SUFFIX, DFS);
|
||||
df.setStrict(false);
|
||||
assertEquals("1" + MINUS_PATTERN, df.format(df.parse("1" + sign)));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testStrictPrefix(String sign) throws ParseException {
|
||||
var df = new DecimalFormat(PREFIX, DFS);
|
||||
df.setStrict(true);
|
||||
if (sign.equals(MINUS_PATTERN)) {
|
||||
assertEquals(MINUS_PATTERN + "1", df.format(df.parse(sign + "1")));
|
||||
} else {
|
||||
assertThrows(ParseException.class, () -> df.parse(sign + "1"));
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testStrictSuffix(String sign) throws ParseException {
|
||||
var df = new DecimalFormat(SUFFIX, DFS);
|
||||
df.setStrict(true);
|
||||
if (sign.equals(MINUS_PATTERN)) {
|
||||
assertEquals("1" + MINUS_PATTERN, df.format(df.parse("1" + sign)));
|
||||
} else {
|
||||
assertThrows(ParseException.class, () -> df.parse("1" + sign));
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLongPrefix(String sign) throws ParseException {
|
||||
var df = new DecimalFormat(LONG_PREFIX, DFS);
|
||||
assertEquals(MINUS_PATTERN + "neg1", df.format(df.parse(sign + "neg1")));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLongSuffix(String sign) throws ParseException {
|
||||
var df = new DecimalFormat(LONG_SUFFIX, DFS);
|
||||
assertEquals("1neg" + MINUS_PATTERN, df.format(df.parse("1neg" + sign)));
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
class CompactNumberFormatTest {
|
||||
private static final String[] PREFIX = {"+0;-0"};
|
||||
private static final String[] SUFFIX = {"0+;0-"};
|
||||
private static final String[] LONG_PREFIX = {"pos0;-neg0"};
|
||||
private static final String[] LONG_SUFFIX = {"0pos;0neg-"};
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLenientPrefix(String sign) throws ParseException {
|
||||
var cnf = new CompactNumberFormat("0", DFS, PREFIX);
|
||||
cnf.setStrict(false);
|
||||
assertEquals(MINUS_PATTERN + "1", cnf.format(cnf.parse(sign + "1")));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLenientSuffix(String sign) throws ParseException {
|
||||
var cnf = new CompactNumberFormat("0", DFS, SUFFIX);
|
||||
cnf.setStrict(false);
|
||||
assertEquals("1" + MINUS_PATTERN, cnf.format(cnf.parse("1" + sign)));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testStrictPrefix(String sign) throws ParseException {
|
||||
var cnf = new CompactNumberFormat("0", DFS, PREFIX);
|
||||
cnf.setStrict(true);
|
||||
if (sign.equals(MINUS_PATTERN)) {
|
||||
assertEquals(MINUS_PATTERN + "1", cnf.format(cnf.parse(sign + "1")));
|
||||
} else {
|
||||
assertThrows(ParseException.class, () -> cnf.parse(sign + "1"));
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testStrictSuffix(String sign) throws ParseException {
|
||||
var cnf = new CompactNumberFormat("0", DFS, SUFFIX);
|
||||
cnf.setStrict(true);
|
||||
if (sign.equals(MINUS_PATTERN)) {
|
||||
assertEquals("1" + MINUS_PATTERN, cnf.format(cnf.parse("1" + sign)));
|
||||
} else {
|
||||
assertThrows(ParseException.class, () -> cnf.parse("1" + sign));
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLongPrefix(String sign) throws ParseException {
|
||||
var cnf = new CompactNumberFormat("0", DFS, LONG_PREFIX);
|
||||
assertEquals(MINUS_PATTERN + "neg1", cnf.format(cnf.parse(sign + "neg1")));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("LenientMinusSignTest#minus")
|
||||
public void testLongSuffix(String sign) throws ParseException {
|
||||
var cnf = new CompactNumberFormat("0", DFS, LONG_SUFFIX);
|
||||
assertEquals("1neg" + MINUS_PATTERN, cnf.format(cnf.parse( "1neg" + sign)));
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user