1 /*
2 * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 /*
24 * @test
25 * @bug 8177552 8217254
26 * @summary Checks the validity of compact number patterns specified through
27 * CompactNumberFormat constructor
28 * @run testng/othervm TestCompactPatternsValidity
29 */
30
31 import java.math.BigDecimal;
32 import java.math.BigInteger;
33 import java.text.CompactNumberFormat;
34 import java.text.DecimalFormatSymbols;
35 import java.text.ParseException;
36 import java.util.List;
37 import java.util.Locale;
38 import org.testng.annotations.DataProvider;
39 import org.testng.annotations.Test;
40
41 public class TestCompactPatternsValidity {
42
43 // Max range 10^4
44 private static final String[] COMPACT_PATTERN1 = new String[]{"0", "0", "0", "0K", "00K"};
45 // Quoted special character '.' as prefix
50 private static final String[] COMPACT_PATTERN4 = new String[]{"", "", "H0H", "0K", "00K", "H0G"};
51 // Differing while specifying prefix and suffix
52 private static final String[] COMPACT_PATTERN5 = new String[]{"", "", "", "0K", "K0"};
53 // Containing both prefix ('.') and suffix (K)
54 private static final String[] COMPACT_PATTERN6 = new String[]{"0", "", "", "'.'0K"};
55 // Quoted special character ',' as suffix
56 private static final String[] COMPACT_PATTERN7 = new String[]{"", "0", "0", "0K','"};
57 // Most commonly used type of compact patterns with 15 elements
58 private static final String[] COMPACT_PATTERN8 = new String[]{"", "", "", "0K", "00K", "000K", "0M",
59 "00M", "000M", "0B", "00B", "000B", "0T", "00T", "000T"};
60 // All empty or special patterns; checking the default formatting behaviour
61 private static final String[] COMPACT_PATTERN9 = new String[]{"", "", "", "0", "0", "", "", "", "", "", "", "", "", "", ""};
62 // Patterns beyond 10^19; divisors beyond long range
63 private static final String[] COMPACT_PATTERN10 = new String[]{"", "", "", "0K", "00K", "000K", "0M", "00M",
64 "000M", "0B", "00B", "000B", "0T", "00T", "000T", "0L", "00L", "000L", "0XL", "00XL"};
65 // Containing positive;negative subpatterns
66 private static final String[] COMPACT_PATTERN11 = new String[]{"", "", "", "elfu 0;elfu -0", "elfu 00;elfu -00",
67 "elfu 000;elfu -000", "milioni 0;milioni -0", "milioni 00;milioni -00", "milioni 000;milioni -000"};
68 // Containing both prefix and suffix and positive;negative subpatern
69 private static final String[] COMPACT_PATTERN12 = new String[]{"", "", "H0H;H-0H", "0K;0K-", "00K;-00K", "H0G;-H0G"};
70
71 @DataProvider(name = "invalidPatterns")
72 Object[][] invalidCompactPatterns() {
73 return new Object[][]{
74 // compact patterns
75 // Pattern containing unquoted special character '.'
76 {new String[]{"", "", "", "0K", "00K."}},
77 // Pattern containing invalid single quote
78 {new String[]{"", "", "", "0 'do", "00K"}},
79 {new String[]{"", "", "", "0K", "00 don't"}},
80 // A non empty pattern containing no 0s (min integer digits)
81 {new String[]{"K", "0K", "00K"}},
82 // 0s (min integer digits) exceeding for the range at index 3
83 {new String[]{"", "", "0K", "00000K"}},
84 // null as a compact pattern
85 {new String[]{"", "", null, "00K"}},};
86 }
87
88 @DataProvider(name = "validPatternsFormat")
89 Object[][] validPatternsFormat() {
90 return new Object[][]{
91 // compact patterns, numbers, expected output
92 {COMPACT_PATTERN1, List.of(200, 1000, 3000, 500000), List.of("200", "1K", "3K", "500K")},
93 {COMPACT_PATTERN2, List.of(1, 20, 3000), List.of("1", ".K2", ".K300")},
94 {COMPACT_PATTERN3, List.of(100.99, 1000, 30000), List.of("101", "1K", "30K.")},
95 {COMPACT_PATTERN4, List.of(0.0, 500, -500, 30000, 5000000), List.of("0", "H5H", "-H5H", "30K", "H50G")},
96 {COMPACT_PATTERN5, List.of(100, 1000, 30000), List.of("100", "1K", "K3")},
97 {COMPACT_PATTERN6, List.of(20.99, 1000, 30000), List.of("21", ".1K", ".30K")},
98 {COMPACT_PATTERN7, List.of(100, 1000, new BigInteger("12345678987654321")), List.of("100", "1K,", "12345678987654K,")},
99 {COMPACT_PATTERN8, List.of(new BigInteger("223565686837667632"), new BigDecimal("12322456774334.89766"), 30000, 3456.78),
100 List.of("223566T", "12T", "30K", "3K")},
101 {COMPACT_PATTERN9, List.of(new BigInteger("223566000000000000"), new BigDecimal("12345678987654567"), 30000, 3000),
102 List.of("223,566,000,000,000,000", "12,345,678,987,654,567", "30,000", "3,000")},
103 {COMPACT_PATTERN10, List.of(new BigInteger("100000000000000000"), new BigInteger("10000000000000000000"), new BigDecimal("555555555555555555555.89766"), 30000),
104 List.of("100L", "10XL", "556XL", "30K")},
105 {COMPACT_PATTERN11, List.of(20.99, -20.99, 1000, -1000, 30000, -30000, new BigInteger("12345678987654321"), new BigInteger("-12345678987654321")),
106 List.of("21", "-21", "elfu 1", "elfu -1", "elfu 30", "elfu -30", "milioni 12345678988", "milioni -12345678988")},
107 {COMPACT_PATTERN12, List.of(0, 500, -500, 30000, -3000, 5000000), List.of("0", "H5H", "H-5H", "30K", "3K-", "H50G")},};
108 }
109
110 @DataProvider(name = "validPatternsParse")
111 Object[][] validPatternsParse() {
112 return new Object[][]{
113 // compact patterns, parse string, expected output
114 {COMPACT_PATTERN1, List.of(".56", "200", ".1K", "3K", "500K"), List.of(0.56, 200L, 100L, 3000L, 500000L)},
115 {COMPACT_PATTERN2, List.of("1", ".K2", ".K300"), List.of(1L, 20L, 3000L)},
116 {COMPACT_PATTERN3, List.of("101", "1K", "30K."), List.of(101L, 1000L, 30000L)},
117 {COMPACT_PATTERN4, List.of("0", "H5H", "-H5H", "30K", "H50G"), List.of(0L, 500L, -500L, 30000L, 5000000L)},
118 {COMPACT_PATTERN5, List.of("100", "1K", "K3"), List.of(100L, 1000L, 30000L)},
119 {COMPACT_PATTERN6, List.of("21", ".1K", ".30K"), List.of(21L, 1000L, 30000L)},
120 {COMPACT_PATTERN7, List.of("100", "1K,", "12345678987654K,"), List.of(100L, 1000L, 12345678987654000L)},
121 {COMPACT_PATTERN8, List.of("223566T", "12T", "30K", "3K"), List.of(223566000000000000L, 12000000000000L, 30000L, 3000L)},
122 {COMPACT_PATTERN10, List.of("1L", "100L", "10XL", "556XL", "30K"), List.of(1000000000000000L, 100000000000000000L, 1.0E19, 5.56E20, 30000L)},
123 {COMPACT_PATTERN11, List.of("21", "-21", "100.90", "-100.90", "elfu 1", "elfu -1", "elfu 30", "elfu -30", "milioni 12345678988", "milioni -12345678988"),
124 List.of(21L, -21L, 100.90, -100.90, 1000L, -1000L, 30000L, -30000L, 12345678988000000L, -12345678988000000L)},
125 {COMPACT_PATTERN12, List.of("0", "H5H", "H-5H", "30K", "30K-", "H50G"), List.of(0L, 500L, -500L, 30000L, -30000L, 5000000L)},};
126 }
127
128 @Test(dataProvider = "invalidPatterns",
129 expectedExceptions = IllegalArgumentException.class)
130 public void testInvalidCompactPatterns(String[] compactPatterns) {
131 new CompactNumberFormat("#,##0.0#", DecimalFormatSymbols
132 .getInstance(Locale.US), compactPatterns);
133 }
134
135 @Test(dataProvider = "validPatternsFormat")
136 public void testValidPatternsFormat(String[] compactPatterns,
137 List<Object> numbers, List<String> expected) {
138 CompactNumberFormat fmt = new CompactNumberFormat("#,##0.0#",
139 DecimalFormatSymbols.getInstance(Locale.US), compactPatterns);
140 for (int index = 0; index < numbers.size(); index++) {
141 CompactFormatAndParseHelper.testFormat(fmt, numbers.get(index),
142 expected.get(index));
143 }
144 }
145
146 @Test(dataProvider = "validPatternsParse")
147 public void testValidPatternsParse(String[] compactPatterns,
148 List<String> parseString, List<Number> numbers) throws ParseException {
149 CompactNumberFormat fmt = new CompactNumberFormat("#,##0.0#",
150 DecimalFormatSymbols.getInstance(Locale.US), compactPatterns);
151 for (int index = 0; index < parseString.size(); index++) {
152 CompactFormatAndParseHelper.testParse(fmt, parseString.get(index),
153 numbers.get(index), null, null);
154 }
155 }
156 }
|
1 /*
2 * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 /*
24 * @test
25 * @bug 8177552 8217254 8251499
26 * @summary Checks the validity of compact number patterns specified through
27 * CompactNumberFormat constructor
28 * @run testng/othervm TestCompactPatternsValidity
29 */
30
31 import java.math.BigDecimal;
32 import java.math.BigInteger;
33 import java.text.CompactNumberFormat;
34 import java.text.DecimalFormatSymbols;
35 import java.text.ParseException;
36 import java.util.List;
37 import java.util.Locale;
38 import org.testng.annotations.DataProvider;
39 import org.testng.annotations.Test;
40
41 public class TestCompactPatternsValidity {
42
43 // Max range 10^4
44 private static final String[] COMPACT_PATTERN1 = new String[]{"0", "0", "0", "0K", "00K"};
45 // Quoted special character '.' as prefix
50 private static final String[] COMPACT_PATTERN4 = new String[]{"", "", "H0H", "0K", "00K", "H0G"};
51 // Differing while specifying prefix and suffix
52 private static final String[] COMPACT_PATTERN5 = new String[]{"", "", "", "0K", "K0"};
53 // Containing both prefix ('.') and suffix (K)
54 private static final String[] COMPACT_PATTERN6 = new String[]{"0", "", "", "'.'0K"};
55 // Quoted special character ',' as suffix
56 private static final String[] COMPACT_PATTERN7 = new String[]{"", "0", "0", "0K','"};
57 // Most commonly used type of compact patterns with 15 elements
58 private static final String[] COMPACT_PATTERN8 = new String[]{"", "", "", "0K", "00K", "000K", "0M",
59 "00M", "000M", "0B", "00B", "000B", "0T", "00T", "000T"};
60 // All empty or special patterns; checking the default formatting behaviour
61 private static final String[] COMPACT_PATTERN9 = new String[]{"", "", "", "0", "0", "", "", "", "", "", "", "", "", "", ""};
62 // Patterns beyond 10^19; divisors beyond long range
63 private static final String[] COMPACT_PATTERN10 = new String[]{"", "", "", "0K", "00K", "000K", "0M", "00M",
64 "000M", "0B", "00B", "000B", "0T", "00T", "000T", "0L", "00L", "000L", "0XL", "00XL"};
65 // Containing positive;negative subpatterns
66 private static final String[] COMPACT_PATTERN11 = new String[]{"", "", "", "elfu 0;elfu -0", "elfu 00;elfu -00",
67 "elfu 000;elfu -000", "milioni 0;milioni -0", "milioni 00;milioni -00", "milioni 000;milioni -000"};
68 // Containing both prefix and suffix and positive;negative subpatern
69 private static final String[] COMPACT_PATTERN12 = new String[]{"", "", "H0H;H-0H", "0K;0K-", "00K;-00K", "H0G;-H0G"};
70 // A non empty pattern containing no 0s (min integer digits)
71 private static final String[] COMPACT_PATTERN13 =
72 new String[]{"", "", "", "Thousand", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BeyondLong"};
73 private static final String[] COMPACT_PATTERN14 =
74 new String[]{"", "", "", "{one:Kun other:0' 'Kun}"}; // from Somali in CLDR 38
75
76 @DataProvider(name = "invalidPatterns")
77 Object[][] invalidCompactPatterns() {
78 return new Object[][] {
79 // compact patterns
80 // Pattern containing unquoted special character '.'
81 {new String[]{"", "", "", "0K", "00K."}},
82 // Pattern containing invalid single quote
83 {new String[]{"", "", "", "0 'do", "00K"}},
84 {new String[]{"", "", "", "0K", "00 don't"}},
85 // 0s (min integer digits) exceeding for the range at index 3
86 {new String[]{"", "", "0K", "00000K"}},
87 // null as a compact pattern
88 {new String[]{"", "", null, "00K"}},
89 };
90 }
91
92 @DataProvider(name = "validPatternsFormat")
93 Object[][] validPatternsFormat() {
94 return new Object[][] {
95 // compact patterns, pluralRules, numbers, expected output
96 {COMPACT_PATTERN1, null, List.of(200, 1000, 3000, 500000), List.of("200", "1K", "3K", "500K")},
97 {COMPACT_PATTERN2, null, List.of(1, 20, 3000), List.of("1", ".K2", ".K300")},
98 {COMPACT_PATTERN3, null, List.of(100.99, 1000, 30000), List.of("101", "1K", "30K.")},
99 {COMPACT_PATTERN4, null, List.of(0.0, 500, -500, 30000, 5000000), List.of("0", "H5H", "-H5H", "30K", "H50G")},
100 {COMPACT_PATTERN5, null, List.of(100, 1000, 30000), List.of("100", "1K", "K3")},
101 {COMPACT_PATTERN6, null, List.of(20.99, 1000, 30000), List.of("21", ".1K", ".30K")},
102 {COMPACT_PATTERN7, null, List.of(100, 1000, new BigInteger("12345678987654321")), List.of("100", "1K,", "12345678987654K,")},
103 {COMPACT_PATTERN8, null, List.of(new BigInteger("223565686837667632"), new BigDecimal("12322456774334.89766"), 30000, 3456.78),
104 List.of("223566T", "12T", "30K", "3K")},
105 {COMPACT_PATTERN9, null, List.of(new BigInteger("223566000000000000"), new BigDecimal("12345678987654567"), 30000, 3000),
106 List.of("223,566,000,000,000,000", "12,345,678,987,654,567", "30,000", "3,000")},
107 {COMPACT_PATTERN10, null, List.of(new BigInteger("100000000000000000"), new BigInteger("10000000000000000000"), new BigDecimal("555555555555555555555.89766"), 30000),
108 List.of("100L", "10XL", "556XL", "30K")},
109 {COMPACT_PATTERN11, null, List.of(20.99, -20.99, 1000, -1000, 30000, -30000, new BigInteger("12345678987654321"), new BigInteger("-12345678987654321")),
110 List.of("21", "-21", "elfu 1", "elfu -1", "elfu 30", "elfu -30", "milioni 12345678988", "milioni -12345678988")},
111 {COMPACT_PATTERN12, null, List.of(0, 500, -500, 30000, -3000, 5000000), List.of("0", "H5H", "H-5H", "30K", "3K-", "H50G")},
112 {COMPACT_PATTERN13, null, List.of(1000, new BigInteger("10000000000000000000")), List.of("Thousand", "BeyondLong")},
113 {COMPACT_PATTERN14, "one:n = 1", List.of(1000, 2345), List.of("Kun", "2 Kun")},
114 };
115 }
116
117 @DataProvider(name = "validPatternsParse")
118 Object[][] validPatternsParse() {
119 return new Object[][] {
120 // compact patterns, plural rules, parse string, expected output
121 {COMPACT_PATTERN1, null, List.of(".56", "200", ".1K", "3K", "500K"), List.of(0.56, 200L, 100L, 3000L, 500000L)},
122 {COMPACT_PATTERN2, null, List.of("1", ".K2", ".K300"), List.of(1L, 20L, 3000L)},
123 {COMPACT_PATTERN3, null, List.of("101", "1K", "30K."), List.of(101L, 1000L, 30000L)},
124 {COMPACT_PATTERN4, null, List.of("0", "H5H", "-H5H", "30K", "H50G"), List.of(0L, 500L, -500L, 30000L, 5000000L)},
125 {COMPACT_PATTERN5, null, List.of("100", "1K", "K3"), List.of(100L, 1000L, 30000L)},
126 {COMPACT_PATTERN6, null, List.of("21", ".1K", ".30K"), List.of(21L, 1000L, 30000L)},
127 {COMPACT_PATTERN7, null, List.of("100", "1K,", "12345678987654K,"), List.of(100L, 1000L, 12345678987654000L)},
128 {COMPACT_PATTERN8, null, List.of("223566T", "12T", "30K", "3K"), List.of(223566000000000000L, 12000000000000L, 30000L, 3000L)},
129 {COMPACT_PATTERN10, null, List.of("1L", "100L", "10XL", "556XL", "30K"), List.of(1000000000000000L, 100000000000000000L, 1.0E19, 5.56E20, 30000L)},
130 {COMPACT_PATTERN11, null, List.of("21", "-21", "100.90", "-100.90", "elfu 1", "elfu -1", "elfu 30", "elfu -30", "milioni 12345678988", "milioni -12345678988"),
131 List.of(21L, -21L, 100.90, -100.90, 1000L, -1000L, 30000L, -30000L, 12345678988000000L, -12345678988000000L)},
132 {COMPACT_PATTERN12, null, List.of("0", "H5H", "H-5H", "30K", "30K-", "H50G"), List.of(0L, 500L, -500L, 30000L, -30000L, 5000000L)},
133 {COMPACT_PATTERN13, null, List.of("Thousand", "BeyondLong"), List.of(1000L, new BigInteger("10000000000000000000"))},
134 {COMPACT_PATTERN14,"one:n = 1", List.of("Kun", "2 Kun"), List.of(1000L, 2000L)},
135 };
136 }
137
138 @Test(dataProvider = "invalidPatterns",
139 expectedExceptions = IllegalArgumentException.class)
140 public void testInvalidCompactPatterns(String[] compactPatterns) {
141 new CompactNumberFormat("#,##0.0#", DecimalFormatSymbols
142 .getInstance(Locale.US), compactPatterns);
143 }
144
145 @Test(dataProvider = "validPatternsFormat")
146 public void testValidPatternsFormat(String[] compactPatterns, String pluralRules,
147 List<Object> numbers, List<String> expected) {
148 CompactNumberFormat fmt = pluralRules != null ?
149 new CompactNumberFormat("#,##0.0#",
150 DecimalFormatSymbols.getInstance(Locale.US), compactPatterns, pluralRules) :
151 new CompactNumberFormat("#,##0.0#",
152 DecimalFormatSymbols.getInstance(Locale.US), compactPatterns);
153 for (int index = 0; index < numbers.size(); index++) {
154 CompactFormatAndParseHelper.testFormat(fmt, numbers.get(index),
155 expected.get(index));
156 }
157 }
158
159 @Test(dataProvider = "validPatternsParse")
160 public void testValidPatternsParse(String[] compactPatterns, String pluralRules,
161 List<String> parseString, List<Number> numbers) throws ParseException {
162 CompactNumberFormat fmt = pluralRules != null ?
163 new CompactNumberFormat("#,##0.0#",
164 DecimalFormatSymbols.getInstance(Locale.US), compactPatterns, pluralRules) :
165 new CompactNumberFormat("#,##0.0#",
166 DecimalFormatSymbols.getInstance(Locale.US), compactPatterns);
167 for (int index = 0; index < parseString.size(); index++) {
168 CompactFormatAndParseHelper.testParse(fmt, parseString.get(index),
169 numbers.get(index), null, null);
170 }
171 }
172 }
|