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 32import java.math.BigDecimal; 33import java.text.*; 34import java.util.*; 35 36public 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} 710