--- /dev/null 2018-10-22 22:34:38.096000000 +0530 +++ new/test/jdk/java/text/Format/CompactNumberFormat/CompactPatternsValidity.java 2018-11-16 17:01:21.540934364 +0530 @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2018, 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 8177552 + * @summary Checks the validity of compact number patterns specified through + * CompactNumberFormat constructor + * @run testng/othervm CompactPatternsValidity + */ + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.text.CompactNumberFormat; +import java.text.DecimalFormatSymbols; +import java.text.ParseException; +import java.util.List; +import java.util.Locale; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; + +public class CompactPatternsValidity { + + @DataProvider(name = "invalidPatterns") + Object[][] invalidCompactPatterns() { + return new Object[][]{ + // compact patterns + // pattern containing unquoted special character '.' + {new String[]{"", "", "", "0K", "0.0K"}}, + // a non empty pattern containing no min integer digits + {new String[]{"K", "0K", "00K"}}, + // min integer digits exceeding for the range at index 3 + {new String[]{"", "", "0K", "00000K"}},}; + } + + @DataProvider(name = "validPatternsFormat") + Object[][] validPatternsFormat() { + return new Object[][]{ + // compact patterns, numbers, expected output + {new String[]{"0", "0", "0", "0K", "00K"}, List.of(200, 1000, 3000, 500000), + List.of("200", "1K", "3K", "500K")}, + {new String[]{"0", "'.'K0"}, List.of(1, 20, 3000), + List.of("1", ".K2", ".K300")}, + {new String[]{"0", "0", "0", "0K", "00K'.'"}, List.of(100.99, 1000, 30000), + List.of("101", "1K", "30K.")}, + // a pattern containing both prefix and suffix + {new String[]{"", "", "H0H", "0K", "00K", "H0G"}, List.of(0.0, 500, -500, 30000, 5000000), + List.of("0", "H5H", "-H5H", "30K", "H50G")}, + // inconsistency across patterns regarding prefix and suffix + {new String[]{"", "", "", "0K", "K0"}, List.of(100, 1000, 30000), + List.of("100", "1K", "K3")}, + // a pattern containing both prefix ('.') and suffix (K) + {new String[]{"0", "", "", "'.'0K"}, List.of(20.99, 1000, 30000), + List.of("21", ".1K", ".30K")}, + {new String[]{"", "0", "0", "0K','"}, List.of(100, 1000, new BigInteger("12345678987654321")), + List.of("100", "1K,", "12345678987654K,")}, + {new String[]{"", "", "", "0K", "00K", "000K", "0M", "00M", + "000M", "0B", "00B", "000B", "0T", "00T", "000T"}, + List.of(new BigInteger("223565686837667632"), + new BigDecimal("12322456774334.89766"), 30000, 3456.78), + List.of("223566T", "12T", "30K", "3K")}, + // all empty or special patterns; checking the default formatting behaviour + {new String[]{"", "", "", "0", "0", "", "", "", "", "", "", "", "", "", ""}, + List.of(new BigInteger("223566000000000000"), + new BigDecimal("12345678987654567"), 30000, 3000), + List.of("223,566,000,000,000,000", "12,345,678,987,654,567", "30,000", "3,000")}, + // patterns beyond 10^19; divisors beyond long range + {new String[]{"", "", "", "0K", "00K", "000K", "0M", "00M", "000M", + "0B", "00B", "000B", "0T", "00T", "000T", "0L", "00L", + "000L", "0XL", "00XL"}, + List.of(new BigInteger("100000000000000000"), + new BigInteger("10000000000000000000"), + new BigDecimal("555555555555555555555.89766"), 30000), + List.of("100L", "10XL", "556XL", "30K")}, + // patterns containing positive;negative subpatterns + {new String[]{"", "", "", "elfu 0;elfu -0", "elfu 00;elfu -00", + "elfu 000;elfu -000", "milioni 0;milioni -0", + "milioni 00;milioni -00", "milioni 000;milioni -000"}, + List.of(20.99, -20.99, 1000, -1000, 30000, -30000, + new BigInteger("12345678987654321"), + new BigInteger("-12345678987654321")), + List.of("21", "-21", "elfu 1", "elfu -1", "elfu 30", "elfu -30", + "milioni 12345678988", "milioni -12345678988")}, + // patterns containing both prefix and suffix and positive;negative + // subpatern + {new String[]{"", "", "H0H;H-0H", "0K;0K-", "00K;-00K", "H0G;-H0G"}, + List.of(0, 500, -500, 30000, -3000, 5000000), + List.of("0", "H5H", "H-5H", "30K", "3K-", "H50G")},}; + } + + @DataProvider(name = "validPatternsParse") + Object[][] validPatternsParse() { + return new Object[][]{ + // compact patterns, parse string, expected output + {new String[]{"0", "0", "0", "0K", "00K"}, + List.of(".56", "200", ".1K", "3K", "500K"), + List.of(0.56, 200L, 100L, 3000L, 500000L)}, + {new String[]{"0", "'.'K0"}, List.of("1", ".K2", ".K300"), + List.of(1L, 20L, 3000L)}, + {new String[]{"0", "0", "0", "0K", "00K'.'"}, + List.of("101", "1K", "30K."), List.of(101L, 1000L, 30000L)}, + // a pattern containing both prefix and suffix + {new String[]{"", "", "H0H", "0K", "00K", "H0G"}, + List.of("0", "H5H", "-H5H", "30K", "H50G"), + List.of(0L, 500L, -500L, 30000L, 5000000L)}, + // inconsistency across patterns regarding prefix and suffix + {new String[]{"", "", "", "0K", "K0"}, List.of("100", "1K", "K3"), + List.of(100L, 1000L, 30000L)}, + // a pattern containing both prefix ('.') and suffix (K) + {new String[]{"0", "", "", "'.'0K"}, List.of("21", ".1K", ".30K"), + List.of(21L, 1000L, 30000L)}, + {new String[]{"", "0", "0", "0K','"}, + List.of("100", "1K,", "12345678987654K,"), + List.of(100L, 1000L, 12345678987654000L)}, + {new String[]{"", "", "", "0K", "00K", "000K", "0M", "00M", + "000M", "0B", "00B", "000B", "0T", "00T", "000T"}, + List.of("223566T", "12T", "30K", "3K"), + List.of(223566000000000000L, 12000000000000L, 30000L, 3000L)}, + // patterns beyond 10^19; divisors beyond long range + {new String[]{"", "", "", "0K", "00K", "000K", "0M", "00M", "000M", + "0B", "00B", "000B", "0T", "00T", "000T", "0L", "00L", + "000L", "0XL", "00XL"}, + List.of("1L", "100L", "10XL", "556XL", "30K"), + List.of(1000000000000000L, 100000000000000000L, 1.0E19, 5.56E20, 30000L)}, + // patterns containing positive;negative subpatterns + {new String[]{"", "", "", "elfu 0;elfu -0", "elfu 00;elfu -00", + "elfu 000;elfu -000", "milioni 0;milioni -0", + "milioni 00;milioni -00", "milioni 000;milioni -000"}, + List.of("21", "-21", "100.90", "-100.90", "elfu 1", "elfu -1", + "elfu 30", "elfu -30", "milioni 12345678988", + "milioni -12345678988"), + List.of(21L, -21L, 100.90, -100.90, 1000L, -1000L, 30000L, -30000L, + 12345678988000000L, -12345678988000000L)}, + // patterns containing both prefix and suffix and positive;negative + // subpatern + {new String[]{"", "", "H0H;H-0H", "0K;0K-", "00K;-00K", "H0G;-H0G"}, + List.of("0", "H5H", "H-5H", "30K", "30K-", "H50G"), + List.of(0L, 500L, -500L, 30000L, -30000L, 5000000L)},}; + } + + @Test(dataProvider = "invalidPatterns", + expectedExceptions = RuntimeException.class) + public void testInvalidCompactPatterns(String[] compactPatterns) { + new CompactNumberFormat("#,##0.0#", DecimalFormatSymbols + .getInstance(Locale.US), compactPatterns); + } + + @Test(dataProvider = "validPatternsFormat") + public void testValidPatternsFormat(String[] compactPatterns, + List numbers, List expected) { + CompactNumberFormat fmt = new CompactNumberFormat("#,##0.0#", + DecimalFormatSymbols.getInstance(Locale.US), compactPatterns); + for (int index = 0; index < numbers.size(); index++) { + CompactFormatAndParse.testFormat(fmt, numbers.get(index), + expected.get(index)); + } + } + + @Test(dataProvider = "validPatternsParse") + public void testValidPatternsParse(String[] compactPatterns, + List parseString, List numbers) throws ParseException { + CompactNumberFormat fmt = new CompactNumberFormat("#,##0.0#", + DecimalFormatSymbols.getInstance(Locale.US), compactPatterns); + for (int index = 0; index < parseString.size(); index++) { + CompactFormatAndParse.testParse(fmt, parseString.get(index), + numbers.get(index), null, null); + } + } +}