|
1 /* |
|
2 * Copyright (c) 2003, 2016, 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 /* |
|
25 * @test |
|
26 * @bug 4018937 8008577 |
|
27 * @summary Confirm that methods which are newly added to support BigDecimal and BigInteger work as expected. |
|
28 * @library /java/text/testlib |
|
29 * @run main/othervm -Djava.locale.providers=COMPAT,SPI BigDecimalParse |
|
30 */ |
|
31 |
|
32 import java.math.BigDecimal; |
|
33 import java.text.*; |
|
34 import java.util.*; |
|
35 |
|
36 public class BigDecimalParse extends IntlTest { |
|
37 |
|
38 public static void main(String[] args) throws Exception { |
|
39 Locale loc = Locale.getDefault(); |
|
40 try { |
|
41 Locale.setDefault(Locale.US); |
|
42 new BigDecimalParse().run(args); |
|
43 } finally { |
|
44 // restore the reserved locale |
|
45 Locale.setDefault(loc); |
|
46 } |
|
47 } |
|
48 |
|
49 static final String nonsep_int = |
|
50 "123456789012345678901234567890123456789012345678901234567890" + |
|
51 "123456789012345678901234567890123456789012345678901234567890" + |
|
52 "123456789012345678901234567890123456789012345678901234567890" + |
|
53 "123456789012345678901234567890123456789012345678901234567890" + |
|
54 "123456789012345678901234567890123456789012345678901234567890" + |
|
55 "123456789012345678901234567890123456789012345678901234567890"; |
|
56 |
|
57 static final String sep_int = |
|
58 "123,456,789,012,345,678,901,234,567,890," + |
|
59 "123,456,789,012,345,678,901,234,567,890," + |
|
60 "123,456,789,012,345,678,901,234,567,890," + |
|
61 "123,456,789,012,345,678,901,234,567,890," + |
|
62 "123,456,789,012,345,678,901,234,567,890," + |
|
63 "123,456,789,012,345,678,901,234,567,890," + |
|
64 "123,456,789,012,345,678,901,234,567,890," + |
|
65 "123,456,789,012,345,678,901,234,567,890," + |
|
66 "123,456,789,012,345,678,901,234,567,890," + |
|
67 "123,456,789,012,345,678,901,234,567,890," + |
|
68 "123,456,789,012,345,678,901,234,567,890," + |
|
69 "123,456,789,012,345,678,901,234,567,890"; |
|
70 |
|
71 static final String nonsep_zero = |
|
72 "000000000000000000000000000000000000000000000000000000000000" + |
|
73 "000000000000000000000000000000000000000000000000000000000000" + |
|
74 "000000000000000000000000000000000000000000000000000000000000" + |
|
75 "000000000000000000000000000000000000000000000000000000000000" + |
|
76 "000000000000000000000000000000000000000000000000000000000000" + |
|
77 "000000000000000000000000000000000000000000000000000000000000"; |
|
78 |
|
79 static final String sep_zero = |
|
80 "000,000,000,000,000,000,000,000,000,000," + |
|
81 "000,000,000,000,000,000,000,000,000,000," + |
|
82 "000,000,000,000,000,000,000,000,000,000," + |
|
83 "000,000,000,000,000,000,000,000,000,000," + |
|
84 "000,000,000,000,000,000,000,000,000,000," + |
|
85 "000,000,000,000,000,000,000,000,000,000," + |
|
86 "000,000,000,000,000,000,000,000,000,000," + |
|
87 "000,000,000,000,000,000,000,000,000,000," + |
|
88 "000,000,000,000,000,000,000,000,000,000," + |
|
89 "000,000,000,000,000,000,000,000,000,000," + |
|
90 "000,000,000,000,000,000,000,000,000,000," + |
|
91 "000,000,000,000,000,000,000,000,000,000"; |
|
92 |
|
93 static final String fra = |
|
94 "012345678901234567890123456789012345678901234567890123456789" + |
|
95 "012345678901234567890123456789012345678901234567890123456789" + |
|
96 "012345678901234567890123456789012345678901234567890123456789" + |
|
97 "012345678901234567890123456789012345678901234567890123456789" + |
|
98 "012345678901234567890123456789012345678901234567890123456789" + |
|
99 "012345678901234567890123456789012345678901234567890123456789"; |
|
100 |
|
101 |
|
102 Number parsed = null; |
|
103 ParsePosition pp; |
|
104 boolean exceptionOccurred; |
|
105 String msg; |
|
106 DecimalFormat df; |
|
107 |
|
108 /** |
|
109 * Test for normal big numbers which have the fraction part |
|
110 */ |
|
111 void test_Parse_in_DecimalFormat_BigDecimal() { |
|
112 df = new DecimalFormat(); |
|
113 df.setParseBigDecimal(true); |
|
114 |
|
115 // From: 1234...7890.012...789 |
|
116 // To: BigDecimal 1234...7890.012...789 |
|
117 check(nonsep_int + "." + fra, new BigDecimal(nonsep_int + "." + fra)); |
|
118 |
|
119 // From: -1,234...7,890.012...789 |
|
120 // To: BigDecimal -1234...7890.012...789 |
|
121 check("-" + sep_int + "." + fra, |
|
122 new BigDecimal("-" + nonsep_int + "." + fra)); |
|
123 |
|
124 // From: 000...0000.0...0 |
|
125 // To: BigDecimal 0E-360 |
|
126 check(nonsep_zero + "." + nonsep_zero, |
|
127 new BigDecimal(nonsep_zero + "." + nonsep_zero)); |
|
128 |
|
129 // From: 0.000...0000123...789E370 |
|
130 // To: BigDecimal 0.0123...789 |
|
131 check("0.0000000000" + nonsep_zero + fra + "E370", |
|
132 new BigDecimal("0.0000000000" + nonsep_zero + fra + "E370")); |
|
133 |
|
134 // From: 0.1123...890E-360 |
|
135 // To: BigDecimal 1.123...890E-361 |
|
136 check("0.1" + nonsep_int + "E-360", |
|
137 new BigDecimal("0.1" + nonsep_int + "E-360")); |
|
138 |
|
139 // From: 000...0000.0...0123...7890 |
|
140 // To: BigDecimal 1.234...890E-361 |
|
141 check(nonsep_zero + "." + nonsep_zero + nonsep_int, |
|
142 new BigDecimal(nonsep_zero + "." + nonsep_zero + nonsep_int)); |
|
143 |
|
144 // From: 0.123...890E360 |
|
145 // To: BigDecimal 123...890 |
|
146 check("0." + nonsep_int + "E360", |
|
147 new BigDecimal("0." + nonsep_int + "E360")); |
|
148 } |
|
149 |
|
150 /** |
|
151 * Test for normal big numbers which have the fraction part with multiplier |
|
152 */ |
|
153 void test_Parse_in_DecimalFormat_BigDecimal_usingMultiplier() { |
|
154 df = new DecimalFormat(); |
|
155 df.setParseBigDecimal(true); |
|
156 |
|
157 // From: 250,0...0,000.000...000 |
|
158 // To: 1000...0000.000...000 |
|
159 df.setMultiplier(250000000); |
|
160 check("250,000,000," + sep_zero + "." + nonsep_zero, |
|
161 new BigDecimal("1" + nonsep_zero + "." + nonsep_zero)); |
|
162 |
|
163 // From: -250,0...0,000.000...000 |
|
164 // To: -1000...0000.000...000 |
|
165 check("-250,000,000," + sep_zero + "." + nonsep_zero, |
|
166 new BigDecimal("-1" + nonsep_zero + "." + nonsep_zero)); |
|
167 |
|
168 // From: 250,0...0,000.000...000 |
|
169 // To: -1000...0000.000...000 |
|
170 df.setMultiplier(-250000000); |
|
171 check("250,000,000," + sep_zero + "." + nonsep_zero, |
|
172 new BigDecimal("-1" + nonsep_zero + "." + nonsep_zero)); |
|
173 |
|
174 // From: -250,0...0,000.000...000 |
|
175 // To: 1000...0000.000...000 |
|
176 check("-250,000,000," + sep_zero + "." + nonsep_zero, |
|
177 new BigDecimal("1" + nonsep_zero + "." + nonsep_zero)); |
|
178 |
|
179 // Confirm that ArithmeticException is handled properly |
|
180 // From: 1000.000 |
|
181 // To: 333.333 |
|
182 df.setMultiplier(3); |
|
183 check("1000.000", new BigDecimal("333.333")); |
|
184 |
|
185 // Confirm that ArithmeticException is handled properly |
|
186 // From: 10000.0000 |
|
187 // To: 303.0303 |
|
188 df.setMultiplier(33); |
|
189 check("10000.0000", new BigDecimal("303.0303")); |
|
190 } |
|
191 |
|
192 /** |
|
193 * Test for division by zero (BigDecimal) |
|
194 */ |
|
195 void test_Parse_in_DecimalFormat_BigDecimal_DivisionByZero() { |
|
196 df = new DecimalFormat(); |
|
197 df.setParseBigDecimal(true); |
|
198 df.setMultiplier(0); |
|
199 |
|
200 // From: 1000.000 |
|
201 // To: Double.POSITIVE_INFINITY |
|
202 check("1000.000", new Double(Double.POSITIVE_INFINITY)); |
|
203 |
|
204 // From: -1000 |
|
205 // To: Double.NEGATIVE_INFINITY |
|
206 check("-1000", new Double(Double.NEGATIVE_INFINITY)); |
|
207 |
|
208 // From: -0.00 |
|
209 // To: Double.NaN |
|
210 check("-0.00", new Double(Double.NaN)); |
|
211 } |
|
212 |
|
213 /** |
|
214 * Test for division by zero (Double) |
|
215 */ |
|
216 void test_Parse_in_DecimalFormat_Double_DivisionByZero() { |
|
217 df = new DecimalFormat(); |
|
218 df.setParseBigDecimal(false); |
|
219 df.setMultiplier(0); |
|
220 |
|
221 // From: 1000.000 |
|
222 // To: Double.POSITIVE_INFINITY |
|
223 check("1000.000", new Double(Double.POSITIVE_INFINITY)); |
|
224 |
|
225 // From: -1000.000 |
|
226 // To: Double.NEGATIVE_INFINITY |
|
227 check("-1000.000", new Double(Double.NEGATIVE_INFINITY)); |
|
228 |
|
229 // From: 0.0 |
|
230 // To: Double.NaN |
|
231 check("0.0", new Double(Double.NaN)); |
|
232 |
|
233 // From: -0.0 (Double) |
|
234 // To: Double.NaN |
|
235 check("-0.0", new Double(Double.NaN)); |
|
236 |
|
237 // From: Double.NaN |
|
238 // To: Double.NaN |
|
239 check("\ufffd", new Double(Double.NaN)); |
|
240 |
|
241 // From: Double.POSITIVE_INFINITY |
|
242 // To: Double.NaN |
|
243 check("\u221e", new Double(Double.POSITIVE_INFINITY)); |
|
244 |
|
245 // From: Double.NEGATIVE_INFINITY |
|
246 // To: Double.NaN |
|
247 check("-\u221e", new Double(Double.NEGATIVE_INFINITY)); |
|
248 } |
|
249 |
|
250 /** |
|
251 * Test for division by zero (Long) |
|
252 */ |
|
253 void test_Parse_in_DecimalFormat_Long_DivisionByZero() { |
|
254 df = new DecimalFormat(); |
|
255 df.setParseBigDecimal(false); |
|
256 df.setMultiplier(0); |
|
257 |
|
258 // From: 1000 |
|
259 // To: Double.POSITIVE_INFINITY |
|
260 check("1000", new Double(Double.POSITIVE_INFINITY)); |
|
261 |
|
262 // From: -1000 |
|
263 // To: Double.NEGATIVE_INFINITY |
|
264 check("-1000", new Double(Double.NEGATIVE_INFINITY)); |
|
265 |
|
266 // From: -000 (Long) |
|
267 // To: Double.NaN |
|
268 check("-000", new Double(Double.NaN)); |
|
269 } |
|
270 |
|
271 /** |
|
272 * Test for normal big numbers which don't have the fraction part |
|
273 */ |
|
274 void test_Parse_in_DecimalFormat_BigInteger() { |
|
275 df = new DecimalFormat(); |
|
276 df.setParseBigDecimal(true); |
|
277 |
|
278 // From: 123...890 |
|
279 // To: BigDecimal 123...890 |
|
280 check(nonsep_int + nonsep_int, new BigDecimal(nonsep_int + nonsep_int)); |
|
281 |
|
282 // From: 123,4...7,890 |
|
283 // To: BigDecimal 1234...7890 |
|
284 check(sep_int + "," + sep_int, new BigDecimal(nonsep_int + nonsep_int)); |
|
285 |
|
286 // From: -000...000123...890 |
|
287 // To: BigDecimal -123...890 |
|
288 check("-" + nonsep_zero + nonsep_int, new BigDecimal("-" + nonsep_int)); |
|
289 |
|
290 // From: -000,0...0,000,123,4...7,890 |
|
291 // To: BigDecimal -123...890 |
|
292 check("-" + sep_zero + "," + sep_int, new BigDecimal("-" + nonsep_int)); |
|
293 } |
|
294 |
|
295 /** |
|
296 * Test for normal big numbers which don't have the fraction part with |
|
297 * multiplier |
|
298 */ |
|
299 void test_Parse_in_DecimalFormat_BigInteger_usingMultiplier() { |
|
300 df = new DecimalFormat(); |
|
301 df.setParseBigDecimal(true); |
|
302 |
|
303 // From: 250,0...0,000 |
|
304 // To: 1000...0000 |
|
305 df.setMultiplier(250000000); |
|
306 check("250,000,000," + sep_zero, new BigDecimal("1" + nonsep_zero)); |
|
307 |
|
308 // From: -250,0...0,000 |
|
309 // To: -1000...0000 |
|
310 check("-250,000,000," + sep_zero, new BigDecimal("-1" + nonsep_zero)); |
|
311 |
|
312 // From: 250,0...0,000 |
|
313 // To: -1000...0000 |
|
314 df.setMultiplier(-250000000); |
|
315 check("250,000,000," + sep_zero, new BigDecimal("-1" + nonsep_zero)); |
|
316 |
|
317 // From: -250,0...0,000 |
|
318 // To: 1000...0000 |
|
319 check("-250,000,000," + sep_zero, new BigDecimal("1" + nonsep_zero)); |
|
320 |
|
321 // From: 250,0...0,000E-360 |
|
322 // To: -1000...0000.000...000 |
|
323 check("250,000,000," + sep_zero + "," + sep_zero + "E-360", |
|
324 new BigDecimal("-1" + nonsep_zero + "." + nonsep_zero)); |
|
325 |
|
326 // Confirm that a division which results in a irrational number is done |
|
327 // properly |
|
328 // From: 1000 |
|
329 // To: 333 |
|
330 df.setMultiplier(3); |
|
331 check("1000", new BigDecimal("333")); |
|
332 } |
|
333 |
|
334 /** |
|
335 * Test for special numbers |
|
336 * Double.NaN |
|
337 * Double.POSITIVE_INFINITY |
|
338 * Double.NEGATIVE_INFINITY |
|
339 */ |
|
340 void test_Parse_in_DecimalFormat_SpecialNumber() { |
|
341 df = new DecimalFormat(); |
|
342 df.setParseBigDecimal(true); |
|
343 |
|
344 String[] numbers = { |
|
345 "0", "0.0", "25", "25.0", "25.5", "\u221e", "\ufffd", |
|
346 "-0", "-0.0", "-25", "-25.0", "-25.5", "-\u221e", |
|
347 }; |
|
348 int multipliers[] = {5, -5}; |
|
349 Number[][] expected = { |
|
350 { |
|
351 new BigDecimal("0"), new BigDecimal("0.0"), new BigDecimal("5"), |
|
352 new BigDecimal("5.0"), new BigDecimal("5.1"), |
|
353 new Double(Double.POSITIVE_INFINITY), new Double(Double.NaN), |
|
354 new BigDecimal("0"), new BigDecimal("0.0"), |
|
355 new BigDecimal("-5"), new BigDecimal("-5.0"), |
|
356 new BigDecimal("-5.1"), |
|
357 new Double(Double.NEGATIVE_INFINITY), new Double(Double.NaN), |
|
358 }, |
|
359 { |
|
360 new BigDecimal("0"), new BigDecimal("0.0"), |
|
361 new BigDecimal("-5"), new BigDecimal("-5.0"), |
|
362 new BigDecimal("-5.1"), |
|
363 new Double(Double.NEGATIVE_INFINITY), new Double(Double.NaN), |
|
364 new BigDecimal("0"), new BigDecimal("0.0"), new BigDecimal("5"), |
|
365 new BigDecimal("5.0"), new BigDecimal("5.1"), |
|
366 new Double(Double.POSITIVE_INFINITY), |
|
367 }, |
|
368 }; |
|
369 |
|
370 for (int i = 0; i < multipliers.length; i++) { |
|
371 df.setMultiplier(multipliers[i]); |
|
372 for (int j = 0; j < numbers.length; j++) { |
|
373 check(String.valueOf(numbers[j]), expected[i][j]); |
|
374 } |
|
375 } |
|
376 } |
|
377 |
|
378 /** |
|
379 * Test for special numbers |
|
380 */ |
|
381 void test_Parse_in_DecimalFormat_Other() { |
|
382 df = new DecimalFormat(); |
|
383 df.setParseBigDecimal(true); |
|
384 |
|
385 String[] numbers = { |
|
386 "-9223372036854775808", // Long.MIN_VALUE |
|
387 }; |
|
388 int multipliers[] = {1, -1}; |
|
389 String[][] expected = { |
|
390 {"-9223372036854775808"}, // Long.MIN_VALUE |
|
391 {"9223372036854775808"}, // Long.MAX_VALUE+1 = abs(MIN_VALUE) |
|
392 }; |
|
393 |
|
394 for (int i = 0; i < multipliers.length; i++) { |
|
395 df.setMultiplier(multipliers[i]); |
|
396 for (int j = 0; j < numbers.length; j++) { |
|
397 check(String.valueOf(numbers[j]), |
|
398 new BigDecimal(expected[i][j])); |
|
399 } |
|
400 } |
|
401 } |
|
402 |
|
403 static final String[] patterns = { |
|
404 " {0, number} ", |
|
405 " {0, number} ", |
|
406 " {0, number, currency} ", |
|
407 " {0, number, currency} ", |
|
408 " {0, number, percent} ", |
|
409 " {0, number, percent} ", |
|
410 " {0, number,#,##0.###E0} ", |
|
411 " {0, number,#,##0.###E0} ", |
|
412 |
|
413 " {0, number} ", |
|
414 " {0, number} ", |
|
415 " {0, number, integer} ", |
|
416 " {0, number, integer} ", |
|
417 " {0, number, currency} ", |
|
418 " {0, number, currency} ", |
|
419 " {0, number, percent} ", |
|
420 " {0, number, percent} ", |
|
421 " {0, number,#,##0.###E0} ", |
|
422 " {0, number,#,##0.###E0} ", |
|
423 }; |
|
424 static final String[] from = { |
|
425 " 12,345,678,901,234,567,890.98765432109876543210987654321 ", |
|
426 " -12,345,678,901,234,567,890.98765432109876543210987654321 ", |
|
427 " $12,345,678,901,234,567,890.98765432109876543210987654321 ", |
|
428 " ($12,345,678,901,234,567,890.98765432109876543210987654321) ", |
|
429 " 1,234,567,890,123,456,789,098.76543210987654321098765432100% ", |
|
430 " -1,234,567,890,123,456,789,098.76543210987654321098765432100% ", |
|
431 " 12,345,678,901,234,567,890.98765432109876543210987654321E-20 ", |
|
432 " -12,345,678,901,234,567,890.98765432109876543210987654321E-20 ", |
|
433 |
|
434 " 9,876,543,210,987,654,321,098,765,432,109,876,543,210 ", |
|
435 " -9,876,543,210,987,654,321,098,765,432,109,876,543,210 ", |
|
436 " 9,876,543,210,987,654,321,098,765,432,109,876,543,210E5 ", |
|
437 " -9,876,543,210,987,654,321,098,765,432,109,876,543,210E-5 ", |
|
438 " $9,876,543,210,987,654,321,098,765,432,109,876,543,210.00 ", |
|
439 " ($9,876,543,210,987,654,321,098,765,432,109,876,543,210.00) ", |
|
440 " 987,654,321,098,765,432,109,876,543,210,987,654,321,012% ", |
|
441 " -987,654,321,098,765,432,109,876,543,210,987,654,321,012% ", |
|
442 " 98,765,432,109,876,543,210.98765432109876543210E20 ", |
|
443 " -987,654,321,098,765,432,109,876,543,210,987,654,321,000,000,000,000,000,000,000E-20 ", |
|
444 }; |
|
445 |
|
446 static final String[] expected1 = { // isParseIntegerOnly() == false |
|
447 "12345678901234567890.98765432109876543210987654321", |
|
448 "-12345678901234567890.98765432109876543210987654321", |
|
449 "12345678901234567890.98765432109876543210987654321", |
|
450 "-12345678901234567890.98765432109876543210987654321", |
|
451 "12345678901234567890.98765432109876543210987654321", |
|
452 "-12345678901234567890.98765432109876543210987654321", |
|
453 "0.1234567890123456789098765432109876543210987654321", |
|
454 "-0.1234567890123456789098765432109876543210987654321", |
|
455 |
|
456 "9876543210987654321098765432109876543210", |
|
457 "-9876543210987654321098765432109876543210", |
|
458 "9.876543210987654321098765432109876543210E44", |
|
459 "-98765432109876543210987654321098765.43210", |
|
460 "9876543210987654321098765432109876543210.00", |
|
461 "-9876543210987654321098765432109876543210.00", |
|
462 "9876543210987654321098765432109876543210.12", |
|
463 "-9876543210987654321098765432109876543210.12", |
|
464 "9876543210987654321098765432109876543210", |
|
465 "-9876543210987654321098765432109876543210.00000000000000000000", |
|
466 }; |
|
467 static final int[] parsePosition1 = { |
|
468 60, 61, 61, 63, 64, 65, 64, 65, |
|
469 57, 58, 59, 61, 61, 63, 60, 61, 54, 88, |
|
470 }; |
|
471 |
|
472 /** |
|
473 * Test for MessageFormat: setParseIntegerOnly(false) |
|
474 */ |
|
475 void test_Parse_in_MessageFormat_NotParseIntegerOnly() { |
|
476 for (int i=0; i < patterns.length; i++) { |
|
477 pp = new ParsePosition(0); |
|
478 Object[] parsed = null; |
|
479 |
|
480 try { |
|
481 MessageFormat mf = new MessageFormat(patterns[i]); |
|
482 Format[] formats = mf.getFormats(); |
|
483 for (int j=0; j < formats.length; j++) { |
|
484 ((DecimalFormat)formats[j]).setParseBigDecimal(true); |
|
485 } |
|
486 |
|
487 parsed = mf.parse(from[i], pp); |
|
488 |
|
489 if (pp.getErrorIndex() != -1) { |
|
490 errln("Case" + (i+1) + |
|
491 ": getErrorIndex() returns wrong value. expected:-1, got:"+ |
|
492 pp.getErrorIndex() + " for " + from[i]); |
|
493 } |
|
494 if (pp.getIndex() != parsePosition1[i]) { |
|
495 errln("Case" + (i+1) + |
|
496 ": getIndex() returns wrong value. expected:" + |
|
497 parsePosition1[i] + ", got:"+ pp.getIndex() + |
|
498 " for " + from[i]); |
|
499 } |
|
500 } |
|
501 catch(Exception e) { |
|
502 errln("Unexpected exception: " + e.getMessage()); |
|
503 } |
|
504 |
|
505 checkType(from[i], getType(new BigDecimal(expected1[i])), |
|
506 getType((Number)parsed[0])); |
|
507 checkParse(from[i], new BigDecimal(expected1[i]), |
|
508 (Number)parsed[0]); |
|
509 } |
|
510 } |
|
511 |
|
512 static final String[] expected2 = { // isParseIntegerOnly() == true |
|
513 "12345678901234567890", |
|
514 "-12345678901234567890", |
|
515 "12345678901234567890", |
|
516 "-12345678901234567890", |
|
517 "12345678901234567890", |
|
518 "-12345678901234567890", |
|
519 "0", |
|
520 "0", |
|
521 |
|
522 "9876543210987654321098765432109876543210", |
|
523 "-9876543210987654321098765432109876543210", |
|
524 "9.876543210987654321098765432109876543210E44", |
|
525 "-98765432109876543210987654321098765.43210", |
|
526 "9876543210987654321098765432109876543210", |
|
527 "-9876543210987654321098765432109876543210", |
|
528 "9876543210987654321098765432109876543210.12", |
|
529 "-9876543210987654321098765432109876543210.12", |
|
530 "9876543210987654321098765432109876543210", |
|
531 "-9876543210987654321098765432109876543210.00000000000000000000", |
|
532 }; |
|
533 static final int[][] parsePosition2 = { // {errorIndex, index} |
|
534 /* |
|
535 * Should keep in mind that the expected result is different from |
|
536 * DecimalFormat.parse() for some cases. |
|
537 */ |
|
538 {28, 0}, // parsing stopped at '.' |
|
539 {29, 0}, // parsing stopped at '.' |
|
540 {29, 0}, // parsing stopped at '.' |
|
541 {2, 0}, // parsing stopped at '(' because cannot find ')' |
|
542 {2, 0}, // parsing stopped at the first numeric |
|
543 // because cannot find '%' |
|
544 {2, 0}, // parsing stopped at the first numeric |
|
545 // because cannot find '%' |
|
546 {28, 0}, // parsing stopped at '.' |
|
547 {29, 0}, // parsing stopped at '.' |
|
548 |
|
549 {-1, 57}, {-1, 58}, {-1, 59}, {-1, 61}, |
|
550 {56, 0}, // parsing stopped at '.' |
|
551 // because cannot find '%' |
|
552 {2, 0}, // parsing stopped at '(' because cannot find ')' |
|
553 {-1, 60}, {-1, 61}, |
|
554 {28, 0}, // parsing stopped at '.' |
|
555 {-1, 88}, |
|
556 }; |
|
557 |
|
558 /** |
|
559 * Test for MessageFormat: setParseIntegerOnly(true) |
|
560 */ |
|
561 void test_Parse_in_MessageFormat_ParseIntegerOnly() { |
|
562 for (int i=0; i < patterns.length; i++) { |
|
563 pp = new ParsePosition(0); |
|
564 Object[] parsed = null; |
|
565 |
|
566 try { |
|
567 MessageFormat mf = new MessageFormat(patterns[i]); |
|
568 Format[] formats = mf.getFormats(); |
|
569 for (int j=0; j < formats.length; j++) { |
|
570 ((DecimalFormat)formats[j]).setParseBigDecimal(true); |
|
571 ((DecimalFormat)formats[j]).setParseIntegerOnly(true); |
|
572 } |
|
573 |
|
574 parsed = mf.parse(from[i], pp); |
|
575 |
|
576 if (pp.getErrorIndex() != parsePosition2[i][0]) { |
|
577 errln("Case" + (i+1) + |
|
578 ": getErrorIndex() returns wrong value. expected:" + |
|
579 parsePosition2[i][0] + ", got:"+ pp.getErrorIndex() + |
|
580 " for " + from[i]); |
|
581 } |
|
582 if (pp.getIndex() != parsePosition2[i][1]) { |
|
583 errln("Case" + (i+1) + |
|
584 ": getIndex() returns wrong value. expected:" + |
|
585 parsePosition2[i][1] + ", got:"+ pp.getIndex() + |
|
586 " for " + from[i]); |
|
587 } |
|
588 } |
|
589 catch(Exception e) { |
|
590 errln("Unexpected exception: " + e.getMessage()); |
|
591 } |
|
592 |
|
593 if (parsePosition2[i][0] == -1) { |
|
594 checkType(from[i], getType(new BigDecimal(expected2[i])), |
|
595 getType((Number)parsed[0])); |
|
596 checkParse(from[i], new BigDecimal(expected2[i]), |
|
597 (Number)parsed[0]); |
|
598 } |
|
599 } |
|
600 } |
|
601 |
|
602 static final String[] from3 = { |
|
603 "12,345,678,901,234,567,890.98765432109876543210987654321", |
|
604 "-12,345,678,901,234,567,890.98765432109876543210987654321", |
|
605 "9,876,543,210,987,654,321,098,765,432,109,876,543,210", |
|
606 "-9,876,543,210,987,654,321,098,765,432,109,876,543,210", |
|
607 "1234556790000E-8", |
|
608 }; |
|
609 static final String[] expected3 = { |
|
610 "12345678901234567890", |
|
611 "-12345678901234567890", |
|
612 "9876543210987654321098765432109876543210", |
|
613 "-9876543210987654321098765432109876543210", |
|
614 "12345.56790000", |
|
615 }; |
|
616 static final int[][] parsePosition3 = { // {errorIndex, index} |
|
617 {-1, 26}, |
|
618 {-1, 27}, |
|
619 {-1, 53}, |
|
620 {-1, 54}, |
|
621 {-1, 16}, |
|
622 }; |
|
623 |
|
624 /** |
|
625 * Test for DecimalFormat: setParseIntegerOnly(true) |
|
626 */ |
|
627 void test_Parse_in_DecimalFormat_ParseIntegerOnly() { |
|
628 DecimalFormat df = (DecimalFormat)NumberFormat.getIntegerInstance(); |
|
629 df.setParseBigDecimal(true); |
|
630 |
|
631 for (int i=0; i < from3.length; i++) { |
|
632 pp = new ParsePosition(0); |
|
633 Number parsed = null; |
|
634 |
|
635 try { |
|
636 parsed = df.parse(from3[i], pp); |
|
637 |
|
638 if (pp.getErrorIndex() != parsePosition3[i][0]) { |
|
639 errln("Case" + (i+1) + |
|
640 ": getErrorIndex() returns wrong value. expected:" + |
|
641 parsePosition3[i][0] + ", got:"+ pp.getErrorIndex() + |
|
642 " for " + from3[i]); |
|
643 } |
|
644 if (pp.getIndex() != parsePosition3[i][1]) { |
|
645 errln("Case" + (i+1) + |
|
646 ": getIndex() returns wrong value. expected:" + |
|
647 parsePosition3[i][1] + ", got:"+ pp.getIndex() + |
|
648 " for " + from3[i]); |
|
649 } |
|
650 } |
|
651 catch(Exception e) { |
|
652 errln("Unexpected exception: " + e.getMessage()); |
|
653 } |
|
654 |
|
655 if (parsePosition3[i][0] == -1) { |
|
656 checkType(from3[i], getType(new BigDecimal(expected3[i])), |
|
657 getType(parsed)); |
|
658 checkParse(from3[i], new BigDecimal(expected3[i]), parsed); |
|
659 } |
|
660 } |
|
661 } |
|
662 |
|
663 protected void check(String from, Number to) { |
|
664 pp = new ParsePosition(0); |
|
665 try { |
|
666 parsed = df.parse(from, pp); |
|
667 } |
|
668 catch(Exception e) { |
|
669 exceptionOccurred = true; |
|
670 errln(e.getMessage()); |
|
671 } |
|
672 if (!exceptionOccurred) { |
|
673 checkParse(from, to, parsed); |
|
674 checkType(from, getType(to), getType(parsed)); |
|
675 checkParsePosition(from, from.length(), pp.getIndex()); |
|
676 } |
|
677 } |
|
678 |
|
679 private void checkParse(String orig, Number expected, Number got) { |
|
680 if (!expected.equals(got)) { |
|
681 errln("Parsing... failed." + |
|
682 "\n original: " + orig + |
|
683 "\n parsed: " + got + |
|
684 "\n expected: " + expected + "\n"); |
|
685 } |
|
686 } |
|
687 |
|
688 private void checkType(String orig, String expected, String got) { |
|
689 if (!expected.equals(got)) { |
|
690 errln("Parsing... unexpected Class returned." + |
|
691 "\n original: " + orig + |
|
692 "\n got: " + got + |
|
693 "\n expected: " + expected + "\n"); |
|
694 } |
|
695 } |
|
696 |
|
697 private void checkParsePosition(String orig, int expected, int got) { |
|
698 if (expected != got) { |
|
699 errln("Parsing... wrong ParsePosition returned." + |
|
700 "\n original: " + orig + |
|
701 "\n got: " + got + |
|
702 "\n expected: " + expected + "\n"); |
|
703 } |
|
704 } |
|
705 |
|
706 private String getType(Number number) { |
|
707 return number.getClass().getName(); |
|
708 } |
|
709 } |