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", Double.POSITIVE_INFINITY);
203 
204         // From: -1000
205         // To:   Double.NEGATIVE_INFINITY
206         check("-1000", Double.NEGATIVE_INFINITY);
207 
208         // From: -0.00
209         // To:   Double.NaN
210         check("-0.00", 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", Double.POSITIVE_INFINITY);
224 
225         // From: -1000.000
226         // To:   Double.NEGATIVE_INFINITY
227         check("-1000.000", Double.NEGATIVE_INFINITY);
228 
229         // From: 0.0
230         // To:   Double.NaN
231         check("0.0", Double.NaN);
232 
233         // From: -0.0 (Double)
234         // To:   Double.NaN
235         check("-0.0", Double.NaN);
236 
237         // From: Double.NaN
238         // To:   Double.NaN
239         check("\ufffd", Double.NaN);
240 
241         // From: Double.POSITIVE_INFINITY
242         // To:   Double.NaN
243         check("\u221e", Double.POSITIVE_INFINITY);
244 
245         // From: Double.NEGATIVE_INFINITY
246         // To:   Double.NaN
247         check("-\u221e", 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", Double.POSITIVE_INFINITY);
261 
262         // From: -1000
263         // To:   Double.NEGATIVE_INFINITY
264         check("-1000", Double.NEGATIVE_INFINITY);
265 
266         // From: -000 (Long)
267         // To:   Double.NaN
268         check("-000", 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                 Double.POSITIVE_INFINITY, Double.NaN,
354                 new BigDecimal("0"), new BigDecimal("0.0"),
355                 new BigDecimal("-5"), new BigDecimal("-5.0"),
356                 new BigDecimal("-5.1"),
357                 Double.NEGATIVE_INFINITY, 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                 Double.NEGATIVE_INFINITY, Double.NaN,
364                 new BigDecimal("0"), new BigDecimal("0.0"), new BigDecimal("5"),
365                 new BigDecimal("5.0"), new BigDecimal("5.1"),
366                 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 }