619 lines
27 KiB
Java
619 lines
27 KiB
Java
/*
|
|
* 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
|
|
* @bug 8327640 8331485 8333755 8335668
|
|
* @summary Test suite for NumberFormat parsing with strict leniency
|
|
* @run junit/othervm -Duser.language=en -Duser.country=US StrictParseTest
|
|
* @run junit/othervm -Duser.language=ja -Duser.country=JP StrictParseTest
|
|
* @run junit/othervm -Duser.language=zh -Duser.country=CN StrictParseTest
|
|
* @run junit/othervm -Duser.language=tr -Duser.country=TR StrictParseTest
|
|
* @run junit/othervm -Duser.language=de -Duser.country=DE StrictParseTest
|
|
* @run junit/othervm -Duser.language=fr -Duser.country=FR StrictParseTest
|
|
* @run junit/othervm -Duser.language=ar -Duser.country=AR StrictParseTest
|
|
*/
|
|
|
|
import org.junit.jupiter.api.BeforeEach;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
|
|
import org.junit.jupiter.params.ParameterizedTest;
|
|
import org.junit.jupiter.params.provider.Arguments;
|
|
import org.junit.jupiter.params.provider.MethodSource;
|
|
|
|
import java.text.CompactNumberFormat;
|
|
import java.text.DecimalFormat;
|
|
import java.text.DecimalFormatSymbols;
|
|
import java.text.NumberFormat;
|
|
import java.text.ParseException;
|
|
import java.text.ParsePosition;
|
|
import java.util.Locale;
|
|
import java.util.stream.Stream;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
|
|
|
// Tests strict parsing, this is done by testing the NumberFormat factory instances
|
|
// against a number of locales with different formatting conventions. The locales
|
|
// used all use a grouping size of 3.
|
|
public class StrictParseTest {
|
|
|
|
// Used to retrieve the locale's expected symbols
|
|
private static final DecimalFormatSymbols dfs =
|
|
new DecimalFormatSymbols(Locale.getDefault());
|
|
// We re-use these formats for the respective factory tests
|
|
private static final DecimalFormat dFmt =
|
|
(DecimalFormat) NumberFormat.getNumberInstance(Locale.getDefault());
|
|
private static final DecimalFormat cFmt =
|
|
(DecimalFormat) NumberFormat.getCurrencyInstance(Locale.getDefault());
|
|
private static final DecimalFormat pFmt =
|
|
(DecimalFormat) NumberFormat.getPercentInstance(Locale.getDefault());
|
|
private static final CompactNumberFormat cmpctFmt =
|
|
(CompactNumberFormat) NumberFormat.getCompactNumberInstance(Locale.getDefault(),
|
|
NumberFormat.Style.SHORT);
|
|
private static final NumberFormat[] FORMATS = new NumberFormat[]{dFmt, cFmt, pFmt, cmpctFmt};
|
|
|
|
// Restore defaults before runs
|
|
@BeforeEach
|
|
void beforeEach() {
|
|
for (NumberFormat fmt : FORMATS) {
|
|
fmt.setStrict(true);
|
|
fmt.setParseIntegerOnly(false);
|
|
fmt.setGroupingUsed(true);
|
|
}
|
|
// Grouping Size is not defined at NumberFormat level
|
|
// Compact needs to manually init grouping size
|
|
cmpctFmt.setGroupingSize(3);
|
|
}
|
|
|
|
// ---- NumberFormat tests ----
|
|
|
|
// Guarantee some edge case test input
|
|
@Test // Non-localized, run once
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void uniqueCaseNumberFormatTest() {
|
|
// Format with grouping size = 3, prefix = a, suffix = b
|
|
DecimalFormat nonLocalizedDFmt = new DecimalFormat("a#,#00.00b");
|
|
nonLocalizedDFmt.setStrict(true);
|
|
// Text after suffix
|
|
failParse(nonLocalizedDFmt, "a12bfoo", 3);
|
|
failParse(nonLocalizedDFmt, "a123,456.00bc", 11);
|
|
// Text after prefix
|
|
failParse(nonLocalizedDFmt, "ac123", 0);
|
|
// Missing suffix
|
|
failParse(nonLocalizedDFmt, "a123", 4);
|
|
// Prefix contains a decimal separator
|
|
failParse(nonLocalizedDFmt, ".a123", 0);
|
|
// Test non grouping size of 3
|
|
nonLocalizedDFmt.setGroupingSize(1);
|
|
successParse(nonLocalizedDFmt, "a1,2,3,4b");
|
|
failParse(nonLocalizedDFmt, "a1,2,3,45,6b", 8);
|
|
nonLocalizedDFmt.setGroupingSize(5);
|
|
successParse(nonLocalizedDFmt, "a12345,67890b");
|
|
successParse(nonLocalizedDFmt, "a1234,67890b");
|
|
failParse(nonLocalizedDFmt, "a123456,7890b", 6);
|
|
}
|
|
|
|
|
|
// 8333755: Check that parsing with integer only against a suffix value works
|
|
@Test // Non-localized, run once
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void integerOnlyParseWithSuffixTest() {
|
|
// Some pattern with a suffix
|
|
DecimalFormat fmt = new DecimalFormat("0.00b");
|
|
fmt.setParseIntegerOnly(true);
|
|
assertEquals(5d, successParse(fmt, "5.55b", 1));
|
|
assertEquals(5d, successParse(fmt, "5b", 2));
|
|
assertEquals(5555d, successParse(fmt, "5,555.55b", 5));
|
|
assertEquals(5d, successParse(fmt, "5.55E55b", 1));
|
|
}
|
|
|
|
@Test // Non-localized, only run once
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void badExponentParseNumberFormatTest() {
|
|
// Some fmt, with an "E" exponent string
|
|
DecimalFormat fmt = (DecimalFormat) NumberFormat.getNumberInstance(Locale.US);
|
|
fmt.setStrict(true);
|
|
// Upon non-numeric in exponent, parse will exit early and suffix will not
|
|
// exactly match, causing failure
|
|
failParse(fmt, "1.23E45.1", 7);
|
|
failParse(fmt, "1.23E45.", 7);
|
|
failParse(fmt, "1.23E45FOO3222", 7);
|
|
}
|
|
|
|
// All input Strings should fail
|
|
@ParameterizedTest
|
|
@MethodSource("badParseStrings")
|
|
public void numFmtFailParseTest(String toParse, int expectedErrorIndex) {
|
|
failParse(dFmt, toParse, expectedErrorIndex);
|
|
}
|
|
|
|
// All input Strings should pass and return expected value.
|
|
@ParameterizedTest
|
|
@MethodSource("validParseStrings")
|
|
public void numFmtSuccessParseTest(String toParse, double expectedValue) {
|
|
assertEquals(expectedValue, successParse(dFmt, toParse));
|
|
}
|
|
|
|
// All input Strings should fail
|
|
@ParameterizedTest
|
|
@MethodSource("negativeBadParseStrings")
|
|
public void negNumFmtFailParseTest(String toParse, int expectedErrorIndex) {
|
|
failParse(dFmt, toParse, expectedErrorIndex);
|
|
}
|
|
|
|
// All input Strings should pass and return expected value.
|
|
@ParameterizedTest
|
|
@MethodSource("negativeValidParseStrings")
|
|
public void negNumFmtSuccessParseTest(String toParse, double expectedValue) {
|
|
assertEquals(expectedValue, successParse(dFmt, toParse));
|
|
}
|
|
|
|
// Exception should be thrown if grouping separator occurs anywhere
|
|
// Don't pass badParseStrings as a data source, since they may fail for other reasons
|
|
@ParameterizedTest
|
|
@MethodSource({"validParseStrings", "noGroupingParseStrings"})
|
|
public void numFmtStrictGroupingNotUsed(String toParse) {
|
|
// When grouping is not used, if a grouping separator is found,
|
|
// a failure should occur
|
|
dFmt.setGroupingUsed(false);
|
|
int failIndex = toParse.indexOf(
|
|
dFmt.getDecimalFormatSymbols().getGroupingSeparator());
|
|
if (failIndex > -1) {
|
|
failParse(dFmt, toParse, failIndex);
|
|
} else {
|
|
successParse(dFmt, toParse);
|
|
}
|
|
}
|
|
|
|
// 8333755: Parsing behavior should follow normal strict behavior
|
|
// However the index returned, should be before decimal point
|
|
// and the value parsed equal to the integer portion
|
|
@ParameterizedTest
|
|
@MethodSource("validIntegerOnlyParseStrings")
|
|
public void numFmtStrictIntegerOnlyUsedTest(String toParse, Number expVal) {
|
|
dFmt.setParseIntegerOnly(true);
|
|
int expectedIndex = toParse.indexOf(dfs.getDecimalSeparator());
|
|
if (expectedIndex > -1) {
|
|
assertEquals(successParse(dFmt, toParse, expectedIndex), expVal);
|
|
} else {
|
|
assertEquals(successParse(dFmt, toParse), expVal);
|
|
}
|
|
}
|
|
|
|
// 8335668: Parsing with integer only against String with no integer portion
|
|
// should fail, not return 0. Expected error index should be 0
|
|
@Test
|
|
public void integerParseOnlyFractionOnlyTest() {
|
|
var fmt = NumberFormat.getIntegerInstance();
|
|
failParse(fmt, localizeText("."), 0);
|
|
failParse(fmt, localizeText(".0"), 0);
|
|
failParse(fmt, localizeText(".55"), 0);
|
|
}
|
|
|
|
// 8335668: Parsing with integer only against String with no integer portion
|
|
// should fail, not return 0. Expected error index should be 0
|
|
@Test // Non-localized, run once
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void compactIntegerParseOnlyFractionOnlyTest() {
|
|
var fmt = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
|
|
fmt.setParseIntegerOnly(true);
|
|
failParse(fmt, ".K", 0);
|
|
failParse(fmt, ".0K", 0);
|
|
failParse(fmt, ".55K", 0);
|
|
}
|
|
|
|
// 8333755: Parsing behavior should follow normal strict behavior
|
|
// when it comes to failures.
|
|
@ParameterizedTest
|
|
@MethodSource("badParseStrings")
|
|
public void numFmtStrictIntegerOnlyUsedFailTest(String toParse, int expectedErrorIndex) {
|
|
dFmt.setParseIntegerOnly(true);
|
|
failParse(dFmt, toParse, expectedErrorIndex);
|
|
}
|
|
|
|
// ---- CurrencyFormat tests ----
|
|
@ParameterizedTest
|
|
@MethodSource("currencyBadParseStrings")
|
|
public void currFmtFailParseTest(String toParse, int expectedErrorIndex) {
|
|
failParse(cFmt, toParse, expectedErrorIndex);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("currencyValidParseStrings")
|
|
public void currFmtSuccessParseTest(String toParse, double expectedValue) {
|
|
assertEquals(expectedValue, successParse(cFmt, toParse));
|
|
}
|
|
|
|
// ---- PercentFormat tests ----
|
|
@ParameterizedTest
|
|
@MethodSource("percentBadParseStrings")
|
|
public void percentFmtFailParseTest(String toParse, int expectedErrorIndex) {
|
|
failParse(pFmt, toParse, expectedErrorIndex);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("percentValidParseStrings")
|
|
public void percentFmtSuccessParseTest(String toParse, double expectedValue) {
|
|
assertEquals(expectedValue, successParse(pFmt, toParse));
|
|
}
|
|
|
|
// ---- CompactNumberFormat tests ----
|
|
// Can match to both the decimalFormat patterns and the compact patterns
|
|
// Thus we test leniency for both. Unlike the other tests, this test
|
|
// is only ran against the US Locale and tests against data built with the
|
|
// thousands format (K).
|
|
@ParameterizedTest
|
|
@MethodSource("compactBadParseStrings")
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void compactFmtFailParseTest(String toParse, int expectedErrorIndex) {
|
|
failParse(cmpctFmt, toParse, expectedErrorIndex);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("compactValidParseStrings")
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void compactFmtSuccessParseTest(String toParse, double expectedValue) {
|
|
assertEquals(expectedValue, successParse(cmpctFmt, toParse));
|
|
}
|
|
|
|
// Checks some odd leniency edge cases between matching of default pattern
|
|
// and compact pattern.
|
|
@Test // Non-localized, run once
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void compactFmtEdgeParseTest() {
|
|
// Uses a compact format with unique and non-empty prefix/suffix for both
|
|
// default and compact patterns
|
|
CompactNumberFormat cnf = new CompactNumberFormat("a##0.0#b", DecimalFormatSymbols
|
|
.getInstance(Locale.US), new String[]{"", "c0d"});
|
|
cnf.setStrict(true);
|
|
|
|
// Existing behavior of failed prefix parsing has errorIndex return
|
|
// the beginning of prefix, even if the error occurred later in the prefix.
|
|
// Prefix empty
|
|
failParse(cnf, "12345d", 0);
|
|
failParse(cnf, "1b", 0);
|
|
// Prefix bad
|
|
failParse(cnf, "aa1d", 0);
|
|
failParse(cnf, "cc1d", 0);
|
|
failParse(cnf, "aa1b", 0);
|
|
failParse(cnf, "cc1b", 0);
|
|
|
|
// Suffix error index is always the start of the failed suffix
|
|
// not necessarily where the error occurred in the suffix. This is
|
|
// consistent with the prefix error index behavior.
|
|
// Suffix empty
|
|
failParse(cnf, "a1", 2);
|
|
failParse(cnf, "c1", 2);
|
|
// Suffix bad
|
|
failParse(cnf, "a1dd", 2);
|
|
failParse(cnf, "c1dd", 2);
|
|
failParse(cnf, "a1bb", 2);
|
|
failParse(cnf, "c1bb", 2);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource({"validIntegerOnlyParseStrings", "compactValidIntegerOnlyParseStrings"})
|
|
@EnabledIfSystemProperty(named = "user.language", matches = "en")
|
|
public void compactFmtSuccessParseIntOnlyTest(String toParse, double expectedValue) {
|
|
// compact does not accept exponents
|
|
if (toParse.indexOf('E') > -1) {
|
|
return;
|
|
}
|
|
cmpctFmt.setParseIntegerOnly(true);
|
|
assertEquals(expectedValue, successParse(cmpctFmt, toParse, toParse.length()));
|
|
}
|
|
|
|
// Ensure that on failure, the original index of the PP remains the same
|
|
@Test
|
|
public void parsePositionIndexTest() {
|
|
failParse(dFmt, localizeText("123,456,,789.00"), 8, 4);
|
|
}
|
|
|
|
// ---- Helper test methods ----
|
|
|
|
// Should parse entire String successfully, and return correctly parsed value.
|
|
private Number successParse(NumberFormat fmt, String toParse) {
|
|
return successParse(fmt, toParse, toParse.length());
|
|
}
|
|
|
|
// Overloaded method that allows for an expected ParsePosition index value
|
|
// that is not the string length.
|
|
private Number successParse(NumberFormat fmt, String toParse, int expectedIndex) {
|
|
// For Strings that don't have grouping separators, we test them with
|
|
// grouping off so that they do not fail under the expectation that
|
|
// grouping symbols should occur
|
|
if (!toParse.contains(String.valueOf(dfs.getGroupingSeparator())) &&
|
|
!toParse.contains(String.valueOf(dfs.getMonetaryGroupingSeparator()))) {
|
|
fmt.setGroupingUsed(false);
|
|
}
|
|
Number parsedValue = assertDoesNotThrow(() -> fmt.parse(toParse));
|
|
ParsePosition pp = new ParsePosition(0);
|
|
assertDoesNotThrow(() -> fmt.parse(toParse, pp));
|
|
assertEquals(-1, pp.getErrorIndex(),
|
|
"ParsePosition ErrorIndex is not in correct location");
|
|
assertEquals(expectedIndex, pp.getIndex(),
|
|
"ParsePosition Index is not in correct location");
|
|
fmt.setGroupingUsed(true);
|
|
return parsedValue.doubleValue();
|
|
}
|
|
|
|
// Method which tests a parsing failure. Either a ParseException is thrown,
|
|
// or null is returned depending on which parse method is invoked. When failing,
|
|
// index should remain the initial index set to the ParsePosition while
|
|
// errorIndex is the index of failure.
|
|
private void failParse(NumberFormat fmt, String toParse, int expectedErrorIndex) {
|
|
failParse(fmt, toParse, expectedErrorIndex, 0);
|
|
}
|
|
|
|
// Variant to check non 0 initial parse index
|
|
private void failParse(NumberFormat fmt, String toParse,
|
|
int expectedErrorIndex, int initialParseIndex) {
|
|
ParsePosition pp = new ParsePosition(initialParseIndex);
|
|
assertThrows(ParseException.class, () -> fmt.parse(toParse));
|
|
assertNull(fmt.parse(toParse, pp));
|
|
assertEquals(expectedErrorIndex, pp.getErrorIndex());
|
|
assertEquals(initialParseIndex, pp.getIndex());
|
|
}
|
|
|
|
// ---- Data Providers ----
|
|
// These data providers use US locale grouping and decimal separators
|
|
// for readability, however, the data is tested against multiple locales
|
|
// and is converted appropriately at runtime.
|
|
|
|
// Strings that should fail when parsed with strict leniency.
|
|
// Given as Arguments<String, expectedErrorIndex>
|
|
private static Stream<Arguments> badParseStrings() {
|
|
return Stream.of(
|
|
// Grouping symbol focus
|
|
// Grouping symbol right before decimal
|
|
Arguments.of("1,.", 2),
|
|
Arguments.of("1,.1", 2),
|
|
// Does not end with proper grouping size
|
|
Arguments.of("1,1", 2),
|
|
Arguments.of("1,11", 3),
|
|
Arguments.of("1,1111", 5),
|
|
Arguments.of("11,111,11", 8),
|
|
// Does not end with proper grouping size (with decimal)
|
|
Arguments.of("1,1.", 3),
|
|
Arguments.of("1,11.", 4),
|
|
Arguments.of("1,1111.", 5),
|
|
Arguments.of("11,111,11.", 9),
|
|
// Ends on a grouping symbol
|
|
// Suffix matches correctly, so failure is on the ","
|
|
Arguments.of("11,111,", 6),
|
|
Arguments.of("11,", 2),
|
|
Arguments.of("11,,", 3),
|
|
// Ends with grouping symbol. Failure should occur on grouping,
|
|
// even if non recognized char after
|
|
Arguments.of("11,a", 2),
|
|
// Improper grouping size (with decimal and digits after)
|
|
Arguments.of("1,1.1", 3),
|
|
Arguments.of("1,11.1", 4),
|
|
Arguments.of("1,1111.1", 5),
|
|
Arguments.of("11,111,11.1", 9),
|
|
// Subsequent grouping symbols
|
|
Arguments.of("1,,1", 2),
|
|
Arguments.of("1,1,,1", 3),
|
|
Arguments.of("1,,1,1", 2),
|
|
// Invalid grouping sizes
|
|
Arguments.of("1,11,111", 4),
|
|
Arguments.of("11,11,111", 5),
|
|
Arguments.of("111,11,11", 6),
|
|
// First group is too large
|
|
Arguments.of("1111,11,111", 3),
|
|
Arguments.of("00000,11,111", 3),
|
|
Arguments.of("111,1111111111", 7),
|
|
Arguments.of("111,11", 5),
|
|
Arguments.of("111,1111111111.", 7),
|
|
Arguments.of("111,11.", 6),
|
|
Arguments.of("111,1111111111.", 7),
|
|
// Starts with grouping symbol
|
|
Arguments.of(",111,,1,1", 0),
|
|
Arguments.of(",1", 0),
|
|
Arguments.of(",,1", 0),
|
|
// Leading Zeros (not digits)
|
|
Arguments.of("000,1,1", 5),
|
|
Arguments.of("000,111,11,,1", 10),
|
|
Arguments.of("0,000,1,,1,1", 7),
|
|
// Bad suffix
|
|
Arguments.of("1a", 1),
|
|
// Bad chars in numerical portion
|
|
Arguments.of("123a4", 3),
|
|
Arguments.of("123.4a5", 5),
|
|
// Variety of edge cases
|
|
Arguments.of("123,456.77a", 10),
|
|
Arguments.of("1,234a", 5),
|
|
Arguments.of("1,.a", 2),
|
|
Arguments.of("1.a", 2),
|
|
Arguments.of("1.22a", 4),
|
|
Arguments.of("1.1a1", 3),
|
|
Arguments.of("1,234,a", 5),
|
|
// Double decimal
|
|
Arguments.of("1,234..5", 5))
|
|
.map(args -> Arguments.of(
|
|
localizeText(String.valueOf(args.get()[0])), args.get()[1]));
|
|
}
|
|
|
|
// Strings that should parse fully. (Both in lenient and strict)
|
|
// Given as Arguments<String, expectedParsedNumber>
|
|
private static Stream<Arguments> validParseStrings() {
|
|
return Stream.of(
|
|
Arguments.of("1,234.55", 1234.55d),
|
|
Arguments.of("1,234.5", 1234.5d),
|
|
Arguments.of("1,234.00", 1234d),
|
|
Arguments.of("1,234.0", 1234d),
|
|
Arguments.of("1,234.", 1234d),
|
|
Arguments.of("1", 1d),
|
|
Arguments.of("10", 10d),
|
|
Arguments.of("100", 100d),
|
|
Arguments.of("1000", 1000d),
|
|
Arguments.of("1,000", 1000d),
|
|
Arguments.of("10,000", 10000d),
|
|
Arguments.of("10000", 10000d),
|
|
Arguments.of("100,000", 100000d),
|
|
Arguments.of("1,000,000", 1000000d),
|
|
Arguments.of("10,000,000", 10000000d),
|
|
// Smaller value cases (w/ decimal)
|
|
Arguments.of(".1", .1d),
|
|
Arguments.of("1.1", 1.1d),
|
|
Arguments.of("11.1", 11.1d))
|
|
.map(args -> Arguments.of(
|
|
localizeText(String.valueOf(args.get()[0])), args.get()[1]));
|
|
}
|
|
|
|
// Separate test data set for integer only.
|
|
// Valid parse strings, that would parse successfully for integer/non-integer parse
|
|
private static Stream<Arguments> validIntegerOnlyParseStrings() {
|
|
return Stream.of(
|
|
Arguments.of("234", 234d),
|
|
Arguments.of("234.", 234d),
|
|
Arguments.of("234.1", 234d),
|
|
Arguments.of("1,234.1", 1234d),
|
|
Arguments.of("234.12345", 234d),
|
|
Arguments.of("234.543E23", 234d),
|
|
Arguments.of("234,000.55E22", 234000d),
|
|
Arguments.of("234E22", 234E22))
|
|
.map(args -> Arguments.of(localizeText(String.valueOf(args.get()[0])), args.get()[1]));
|
|
}
|
|
|
|
// Separate test data set for no grouping. Can not use "badParseStrings", as
|
|
// there is test data where the failure may occur from some other issue,
|
|
// not related to grouping
|
|
private static Stream<Arguments> noGroupingParseStrings() {
|
|
return Stream.of(
|
|
Arguments.of("12,34.a"),
|
|
Arguments.of("123,.a1"),
|
|
Arguments.of(",1234"),
|
|
Arguments.of("123,"))
|
|
.map(args -> Arguments.of(localizeText(String.valueOf(args.get()[0]))));
|
|
}
|
|
|
|
// Negative variant of a numerical format
|
|
private static Stream<Arguments> negativeBadParseStrings() {
|
|
return badParseStrings().map(args -> Arguments.of(
|
|
dFmt.getNegativePrefix() + args.get()[0] + dFmt.getNegativeSuffix(),
|
|
(int)args.get()[1] + dFmt.getNegativePrefix().length())
|
|
);
|
|
}
|
|
|
|
// Negative variant of a numerical format
|
|
private static Stream<Arguments> negativeValidParseStrings() {
|
|
return validParseStrings().map(args -> Arguments.of(
|
|
dFmt.getNegativePrefix() + args.get()[0] + dFmt.getNegativeSuffix(),
|
|
(double) args.get()[1] * -1)
|
|
);
|
|
}
|
|
|
|
// Same as original with a percent prefix/suffix.
|
|
// Additionally, increment expected error index if a prefix is added
|
|
private static Stream<Arguments> percentBadParseStrings() {
|
|
return badParseStrings().map(args -> Arguments.of(
|
|
pFmt.getPositivePrefix() + args.get()[0] + pFmt.getPositiveSuffix(),
|
|
(int)args.get()[1] + pFmt.getPositivePrefix().length())
|
|
);
|
|
}
|
|
|
|
// Expected parsed value should be / 100 as it is a percent format.
|
|
private static Stream<Arguments> percentValidParseStrings() {
|
|
return validParseStrings().map(args -> Arguments.of(
|
|
pFmt.getPositivePrefix() + args.get()[0] + pFmt.getPositiveSuffix(),
|
|
(double)args.get()[1] / 100.0)
|
|
);
|
|
}
|
|
|
|
// Same as original with a currency prefix/suffix, but replace separators
|
|
// with monetary variants. Additionally, increment expected error index
|
|
// if a prefix is added
|
|
private static Stream<Arguments> currencyBadParseStrings() {
|
|
return badParseStrings().map(args -> Arguments.of(
|
|
cFmt.getPositivePrefix() + String.valueOf(args.get()[0])
|
|
.replace(dfs.getGroupingSeparator(), dfs.getMonetaryGroupingSeparator())
|
|
.replace(dfs.getDecimalSeparator(), dfs.getMonetaryDecimalSeparator())
|
|
+ cFmt.getPositiveSuffix(),
|
|
(int)args.get()[1] + cFmt.getPositivePrefix().length())
|
|
);
|
|
}
|
|
|
|
private static Stream<Arguments> currencyValidParseStrings() {
|
|
return validParseStrings().map(args -> Arguments.of(
|
|
cFmt.getPositivePrefix() + String.valueOf(args.get()[0])
|
|
.replace(dfs.getGroupingSeparator(), dfs.getMonetaryGroupingSeparator())
|
|
.replace(dfs.getDecimalSeparator(), dfs.getMonetaryDecimalSeparator())
|
|
+ cFmt.getPositiveSuffix(),
|
|
args.get()[1])
|
|
);
|
|
}
|
|
|
|
// Compact Pattern Data Provider provides test input for both DecimalFormat patterns
|
|
// and the compact patterns. As there is no method to retrieve compact patterns,
|
|
// thus test only against US English locale, and use a hard coded K - 1000
|
|
private static Stream<Arguments> compactBadParseStrings() {
|
|
return Stream.concat(
|
|
badParseStrings().map(args -> Arguments.of(args.get()[0], args.get()[1])),
|
|
badParseStrings().map(args -> Arguments.of(args.get()[0] + "K", args.get()[1]))
|
|
);
|
|
}
|
|
|
|
private static Stream<Arguments> compactValidParseStrings() {
|
|
return Stream.concat(
|
|
validParseStrings().map(args -> Arguments.of(
|
|
args.get()[0], args.get()[1])),
|
|
validParseStrings().map(args -> Arguments.of(
|
|
args.get()[0] + "K", (double) args.get()[1] * 1000))
|
|
);
|
|
}
|
|
|
|
private static Stream<Arguments> compactValidIntegerOnlyParseStrings() {
|
|
return validIntegerOnlyParseStrings().map(args -> Arguments.of(
|
|
args.get()[0] + "K", (double) args.get()[1] * 1000)
|
|
);
|
|
}
|
|
|
|
// Replace the grouping and decimal separators with localized variants
|
|
// Used during localization of data
|
|
private static String localizeText(String text) {
|
|
// As this is a single pass conversion, this is safe for multiple replacement,
|
|
// even if a ',' could be a decimal separator for a locale.
|
|
StringBuilder sb = new StringBuilder();
|
|
for (int i = 0; i < text.length(); i++) {
|
|
char c = text.charAt(i);
|
|
if (c == ',') {
|
|
sb.append(dfs.getGroupingSeparator());
|
|
} else if (c == '.') {
|
|
sb.append(dfs.getDecimalSeparator());
|
|
} else if (c == 'E') {
|
|
sb.append(dfs.getExponentSeparator());
|
|
}
|
|
else if (c == '0') {
|
|
sb.append(dfs.getZeroDigit());
|
|
} else {
|
|
sb.append(c);
|
|
}
|
|
}
|
|
return sb.toString();
|
|
}
|
|
}
|