BigDecimalParse.java

/*
 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 4018937 8008577
 * @summary Confirm that methods which are newly added to support BigDecimal and BigInteger work as expected.
 * @library /java/text/testlib
 * @run main/othervm -Djava.locale.providers=COMPAT,SPI BigDecimalParse
 */

import java.math.BigDecimal;
import java.text.*;
import java.util.*;

public class BigDecimalParse extends IntlTest {

    public static void main(String[] args) throws Exception {
        Locale loc = Locale.getDefault();
        try {
            Locale.setDefault(Locale.US);
            new BigDecimalParse().run(args);
        } finally {
            // restore the reserved locale
            Locale.setDefault(loc);
        }
    }

    static final String nonsep_int =
        "123456789012345678901234567890123456789012345678901234567890" +
        "123456789012345678901234567890123456789012345678901234567890" +
        "123456789012345678901234567890123456789012345678901234567890" +
        "123456789012345678901234567890123456789012345678901234567890" +
        "123456789012345678901234567890123456789012345678901234567890" +
        "123456789012345678901234567890123456789012345678901234567890";

    static final String sep_int =
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890," +
        "123,456,789,012,345,678,901,234,567,890";

    static final String nonsep_zero =
        "000000000000000000000000000000000000000000000000000000000000" +
        "000000000000000000000000000000000000000000000000000000000000" +
        "000000000000000000000000000000000000000000000000000000000000" +
        "000000000000000000000000000000000000000000000000000000000000" +
        "000000000000000000000000000000000000000000000000000000000000" +
        "000000000000000000000000000000000000000000000000000000000000";

    static final String sep_zero =
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000," +
        "000,000,000,000,000,000,000,000,000,000";

    static final String fra =
        "012345678901234567890123456789012345678901234567890123456789" +
        "012345678901234567890123456789012345678901234567890123456789" +
        "012345678901234567890123456789012345678901234567890123456789" +
        "012345678901234567890123456789012345678901234567890123456789" +
        "012345678901234567890123456789012345678901234567890123456789" +
        "012345678901234567890123456789012345678901234567890123456789";


    Number parsed = null;
    ParsePosition pp;
    boolean exceptionOccurred;
    String msg;
    DecimalFormat df;

    /**
     * Test for normal big numbers which have the fraction part
     */
    void test_Parse_in_DecimalFormat_BigDecimal() {
        df = new DecimalFormat();
        df.setParseBigDecimal(true);

        // From: 1234...7890.012...789
        // To:   BigDecimal 1234...7890.012...789
        check(nonsep_int + "." + fra, new BigDecimal(nonsep_int + "." + fra));

        // From: -1,234...7,890.012...789
        // To:   BigDecimal -1234...7890.012...789
        check("-" + sep_int    + "." + fra,
              new BigDecimal("-" + nonsep_int + "." + fra));

        // From: 000...0000.0...0
        // To:   BigDecimal 0E-360
        check(nonsep_zero + "." + nonsep_zero,
              new BigDecimal(nonsep_zero + "." + nonsep_zero));

        // From: 0.000...0000123...789E370
        // To:   BigDecimal 0.0123...789
        check("0.0000000000" + nonsep_zero + fra + "E370",
              new BigDecimal("0.0000000000" + nonsep_zero + fra + "E370"));

        // From: 0.1123...890E-360
        // To:   BigDecimal 1.123...890E-361
        check("0.1" + nonsep_int + "E-360",
              new BigDecimal("0.1" + nonsep_int + "E-360"));

        // From: 000...0000.0...0123...7890
        // To:   BigDecimal 1.234...890E-361
        check(nonsep_zero + "." + nonsep_zero + nonsep_int,
              new BigDecimal(nonsep_zero + "." + nonsep_zero + nonsep_int));

        // From: 0.123...890E360
        // To:   BigDecimal 123...890
        check("0." + nonsep_int + "E360",
              new BigDecimal("0." + nonsep_int + "E360"));
    }

    /**
     * Test for normal big numbers which have the fraction part with multiplier
     */
    void test_Parse_in_DecimalFormat_BigDecimal_usingMultiplier() {
        df = new DecimalFormat();
        df.setParseBigDecimal(true);

        // From: 250,0...0,000.000...000
        // To:   1000...0000.000...000
        df.setMultiplier(250000000);
        check("250,000,000," + sep_zero + "." + nonsep_zero,
              new BigDecimal("1" + nonsep_zero + "." + nonsep_zero));

        // From: -250,0...0,000.000...000
        // To:   -1000...0000.000...000
        check("-250,000,000," + sep_zero + "." + nonsep_zero,
              new BigDecimal("-1" + nonsep_zero + "." + nonsep_zero));

        // From: 250,0...0,000.000...000
        // To:   -1000...0000.000...000
        df.setMultiplier(-250000000);
        check("250,000,000," + sep_zero + "." + nonsep_zero,
              new BigDecimal("-1" + nonsep_zero + "." + nonsep_zero));

        // From: -250,0...0,000.000...000
        // To:   1000...0000.000...000
        check("-250,000,000," + sep_zero + "." + nonsep_zero,
              new BigDecimal("1" + nonsep_zero + "." + nonsep_zero));

        // Confirm that ArithmeticException is handled properly
        // From: 1000.000
        // To:   333.333
        df.setMultiplier(3);
        check("1000.000", new BigDecimal("333.333"));

        // Confirm that ArithmeticException is handled properly
        // From: 10000.0000
        // To:   303.0303
        df.setMultiplier(33);
        check("10000.0000", new BigDecimal("303.0303"));
    }

    /**
     * Test for division by zero (BigDecimal)
     */
    void test_Parse_in_DecimalFormat_BigDecimal_DivisionByZero() {
        df = new DecimalFormat();
        df.setParseBigDecimal(true);
        df.setMultiplier(0);

        // From: 1000.000
        // To:   Double.POSITIVE_INFINITY
        check("1000.000", Double.POSITIVE_INFINITY);

        // From: -1000
        // To:   Double.NEGATIVE_INFINITY
        check("-1000", Double.NEGATIVE_INFINITY);

        // From: -0.00
        // To:   Double.NaN
        check("-0.00", Double.NaN);
    }

    /**
     * Test for division by zero (Double)
     */
    void test_Parse_in_DecimalFormat_Double_DivisionByZero() {
        df = new DecimalFormat();
        df.setParseBigDecimal(false);
        df.setMultiplier(0);

        // From: 1000.000
        // To:   Double.POSITIVE_INFINITY
        check("1000.000", Double.POSITIVE_INFINITY);

        // From: -1000.000
        // To:   Double.NEGATIVE_INFINITY
        check("-1000.000", Double.NEGATIVE_INFINITY);

        // From: 0.0
        // To:   Double.NaN
        check("0.0", Double.NaN);

        // From: -0.0 (Double)
        // To:   Double.NaN
        check("-0.0", Double.NaN);

        // From: Double.NaN
        // To:   Double.NaN
        check("\ufffd", Double.NaN);

        // From: Double.POSITIVE_INFINITY
        // To:   Double.NaN
        check("\u221e", Double.POSITIVE_INFINITY);

        // From: Double.NEGATIVE_INFINITY
        // To:   Double.NaN
        check("-\u221e", Double.NEGATIVE_INFINITY);
    }

    /**
     * Test for division by zero (Long)
     */
    void test_Parse_in_DecimalFormat_Long_DivisionByZero() {
        df = new DecimalFormat();
        df.setParseBigDecimal(false);
        df.setMultiplier(0);

        // From: 1000
        // To:   Double.POSITIVE_INFINITY
        check("1000", Double.POSITIVE_INFINITY);

        // From: -1000
        // To:   Double.NEGATIVE_INFINITY
        check("-1000", Double.NEGATIVE_INFINITY);

        // From: -000 (Long)
        // To:   Double.NaN
        check("-000", Double.NaN);
    }

    /**
     * Test for normal big numbers which don't have the fraction part
     */
    void test_Parse_in_DecimalFormat_BigInteger() {
        df = new DecimalFormat();
        df.setParseBigDecimal(true);

        // From: 123...890
        // To:   BigDecimal 123...890
        check(nonsep_int + nonsep_int, new BigDecimal(nonsep_int + nonsep_int));

        // From: 123,4...7,890
        // To:   BigDecimal 1234...7890
        check(sep_int + "," + sep_int, new BigDecimal(nonsep_int + nonsep_int));

        // From: -000...000123...890
        // To:   BigDecimal -123...890
        check("-" + nonsep_zero + nonsep_int, new BigDecimal("-" + nonsep_int));

        // From: -000,0...0,000,123,4...7,890
        // To:   BigDecimal -123...890
        check("-" + sep_zero + "," + sep_int, new BigDecimal("-" + nonsep_int));
    }

    /**
     * Test for normal big numbers which don't have the fraction part with
     * multiplier
     */
    void test_Parse_in_DecimalFormat_BigInteger_usingMultiplier() {
        df = new DecimalFormat();
        df.setParseBigDecimal(true);

        // From: 250,0...0,000
        // To:   1000...0000
        df.setMultiplier(250000000);
        check("250,000,000," + sep_zero, new BigDecimal("1" + nonsep_zero));

        // From: -250,0...0,000
        // To:   -1000...0000
        check("-250,000,000," + sep_zero, new BigDecimal("-1" + nonsep_zero));

        // From: 250,0...0,000
        // To:   -1000...0000
        df.setMultiplier(-250000000);
        check("250,000,000," + sep_zero, new BigDecimal("-1" + nonsep_zero));

        // From: -250,0...0,000
        // To:   1000...0000
        check("-250,000,000," + sep_zero, new BigDecimal("1" + nonsep_zero));

        // From: 250,0...0,000E-360
        // To:   -1000...0000.000...000
        check("250,000,000," + sep_zero + "," + sep_zero + "E-360",
              new BigDecimal("-1" + nonsep_zero + "." + nonsep_zero));

        // Confirm that a division which results in a irrational number is done
        // properly
        // From: 1000
        // To:   333
        df.setMultiplier(3);
        check("1000", new BigDecimal("333"));
    }

    /**
     * Test for special numbers
     *    Double.NaN
     *    Double.POSITIVE_INFINITY
     *    Double.NEGATIVE_INFINITY
     */
    void test_Parse_in_DecimalFormat_SpecialNumber() {
        df = new DecimalFormat();
        df.setParseBigDecimal(true);

        String[] numbers = {
            "0", "0.0", "25", "25.0", "25.5", "\u221e", "\ufffd",
            "-0", "-0.0", "-25", "-25.0", "-25.5", "-\u221e",
        };
        int multipliers[] = {5, -5};
        Number[][] expected = {
            {
                new BigDecimal("0"), new BigDecimal("0.0"), new BigDecimal("5"),
                new BigDecimal("5.0"), new BigDecimal("5.1"),
                Double.POSITIVE_INFINITY, Double.NaN,
                new BigDecimal("0"), new BigDecimal("0.0"),
                new BigDecimal("-5"), new BigDecimal("-5.0"),
                new BigDecimal("-5.1"),
                Double.NEGATIVE_INFINITY, Double.NaN,
            },
            {
                new BigDecimal("0"), new BigDecimal("0.0"),
                new BigDecimal("-5"), new BigDecimal("-5.0"),
                new BigDecimal("-5.1"),
                Double.NEGATIVE_INFINITY, Double.NaN,
                new BigDecimal("0"), new BigDecimal("0.0"), new BigDecimal("5"),
                new BigDecimal("5.0"), new BigDecimal("5.1"),
                Double.POSITIVE_INFINITY,
            },
        };

        for (int i = 0; i < multipliers.length; i++) {
            df.setMultiplier(multipliers[i]);
            for (int j = 0; j < numbers.length; j++) {
                check(String.valueOf(numbers[j]), expected[i][j]);
            }
        }
    }

    /**
     * Test for special numbers
     */
    void test_Parse_in_DecimalFormat_Other() {
        df = new DecimalFormat();
        df.setParseBigDecimal(true);

        String[] numbers = {
            "-9223372036854775808",     // Long.MIN_VALUE
        };
        int multipliers[] = {1, -1};
        String[][] expected = {
            {"-9223372036854775808"},   // Long.MIN_VALUE
            {"9223372036854775808"},    // Long.MAX_VALUE+1 = abs(MIN_VALUE)
        };

        for (int i = 0; i < multipliers.length; i++) {
            df.setMultiplier(multipliers[i]);
            for (int j = 0; j < numbers.length; j++) {
                check(String.valueOf(numbers[j]),
                      new BigDecimal(expected[i][j]));
            }
        }
    }

    static final String[] patterns = {
        "  {0, number}  ",
        "  {0, number}  ",
        "  {0, number, currency}  ",
        "  {0, number, currency}  ",
        "  {0, number, percent}  ",
        "  {0, number, percent}  ",
        "  {0, number,#,##0.###E0}  ",
        "  {0, number,#,##0.###E0}  ",

        "  {0, number}  ",
        "  {0, number}  ",
        "  {0, number, integer}  ",
        "  {0, number, integer}  ",
        "  {0, number, currency}  ",
        "  {0, number, currency}  ",
        "  {0, number, percent}  ",
        "  {0, number, percent}  ",
        "  {0, number,#,##0.###E0}  ",
        "  {0, number,#,##0.###E0}  ",
    };
    static final String[] from = {
        "  12,345,678,901,234,567,890.98765432109876543210987654321  ",
        "  -12,345,678,901,234,567,890.98765432109876543210987654321  ",
        "  $12,345,678,901,234,567,890.98765432109876543210987654321  ",
        "  ($12,345,678,901,234,567,890.98765432109876543210987654321)  ",
        "  1,234,567,890,123,456,789,098.76543210987654321098765432100%  ",
        "  -1,234,567,890,123,456,789,098.76543210987654321098765432100%  ",
        "  12,345,678,901,234,567,890.98765432109876543210987654321E-20  ",
        "  -12,345,678,901,234,567,890.98765432109876543210987654321E-20  ",

        "  9,876,543,210,987,654,321,098,765,432,109,876,543,210  ",
        "  -9,876,543,210,987,654,321,098,765,432,109,876,543,210  ",
        "  9,876,543,210,987,654,321,098,765,432,109,876,543,210E5  ",
        "  -9,876,543,210,987,654,321,098,765,432,109,876,543,210E-5  ",
        "  $9,876,543,210,987,654,321,098,765,432,109,876,543,210.00  ",
        "  ($9,876,543,210,987,654,321,098,765,432,109,876,543,210.00)  ",
        "  987,654,321,098,765,432,109,876,543,210,987,654,321,012%  ",
        "  -987,654,321,098,765,432,109,876,543,210,987,654,321,012%  ",
        "  98,765,432,109,876,543,210.98765432109876543210E20  ",
        "  -987,654,321,098,765,432,109,876,543,210,987,654,321,000,000,000,000,000,000,000E-20  ",
    };

    static final String[] expected1 = { // isParseIntegerOnly() == false
        "12345678901234567890.98765432109876543210987654321",
        "-12345678901234567890.98765432109876543210987654321",
        "12345678901234567890.98765432109876543210987654321",
        "-12345678901234567890.98765432109876543210987654321",
        "12345678901234567890.98765432109876543210987654321",
        "-12345678901234567890.98765432109876543210987654321",
        "0.1234567890123456789098765432109876543210987654321",
        "-0.1234567890123456789098765432109876543210987654321",

        "9876543210987654321098765432109876543210",
        "-9876543210987654321098765432109876543210",
        "9.876543210987654321098765432109876543210E44",
        "-98765432109876543210987654321098765.43210",
        "9876543210987654321098765432109876543210.00",
        "-9876543210987654321098765432109876543210.00",
        "9876543210987654321098765432109876543210.12",
        "-9876543210987654321098765432109876543210.12",
        "9876543210987654321098765432109876543210",
        "-9876543210987654321098765432109876543210.00000000000000000000",
    };
    static final int[] parsePosition1 = {
        60, 61, 61, 63, 64, 65, 64, 65,
        57, 58, 59, 61, 61, 63, 60, 61, 54, 88,
    };

    /**
     * Test for MessageFormat: setParseIntegerOnly(false)
     */
    void test_Parse_in_MessageFormat_NotParseIntegerOnly() {
        for (int i=0; i < patterns.length; i++) {
            pp = new ParsePosition(0);
            Object[] parsed = null;

            try {
                MessageFormat mf = new MessageFormat(patterns[i]);
                Format[] formats = mf.getFormats();
                for (int j=0; j < formats.length; j++) {
                    ((DecimalFormat)formats[j]).setParseBigDecimal(true);
                }

                parsed = mf.parse(from[i], pp);

                if (pp.getErrorIndex() != -1) {
                    errln("Case" + (i+1) +
                          ": getErrorIndex() returns wrong value. expected:-1, got:"+
                          pp.getErrorIndex() + " for " + from[i]);
                }
                if (pp.getIndex() != parsePosition1[i]) {
                    errln("Case" + (i+1) +
                          ": getIndex() returns wrong value. expected:" +
                          parsePosition1[i] + ", got:"+ pp.getIndex() +
                          " for " + from[i]);
                }
            }
            catch(Exception e) {
                errln("Unexpected exception: " + e.getMessage());
            }

            checkType(from[i], getType(new BigDecimal(expected1[i])),
                      getType((Number)parsed[0]));
            checkParse(from[i], new BigDecimal(expected1[i]),
                       (Number)parsed[0]);
        }
    }

    static final String[] expected2 = { // isParseIntegerOnly() == true
        "12345678901234567890",
        "-12345678901234567890",
        "12345678901234567890",
        "-12345678901234567890",
        "12345678901234567890",
        "-12345678901234567890",
        "0",
        "0",

        "9876543210987654321098765432109876543210",
        "-9876543210987654321098765432109876543210",
        "9.876543210987654321098765432109876543210E44",
        "-98765432109876543210987654321098765.43210",
        "9876543210987654321098765432109876543210",
        "-9876543210987654321098765432109876543210",
        "9876543210987654321098765432109876543210.12",
        "-9876543210987654321098765432109876543210.12",
        "9876543210987654321098765432109876543210",
        "-9876543210987654321098765432109876543210.00000000000000000000",
    };
    static final int[][] parsePosition2 = {     // {errorIndex, index}
        /*
         * Should keep in mind that the expected result is different from
         * DecimalFormat.parse() for some cases.
         */
        {28, 0},        // parsing stopped at '.'
        {29, 0},        // parsing stopped at '.'
        {29, 0},        // parsing stopped at '.'
        {2, 0},         // parsing stopped at '(' because cannot find ')'
        {2, 0},         // parsing stopped at the first numeric
                        // because cannot find '%'
        {2, 0},         // parsing stopped at the first numeric
                        // because cannot find '%'
        {28, 0},        // parsing stopped at '.'
        {29, 0},        // parsing stopped at '.'

        {-1, 57}, {-1, 58}, {-1, 59}, {-1, 61},
        {56, 0},        // parsing stopped at '.'
                        // because cannot find '%'
        {2, 0},         // parsing stopped at '(' because cannot find ')'
        {-1, 60}, {-1, 61},
        {28, 0},        // parsing stopped at '.'
        {-1, 88},
    };

    /**
     * Test for MessageFormat: setParseIntegerOnly(true)
     */
    void test_Parse_in_MessageFormat_ParseIntegerOnly() {
        for (int i=0; i < patterns.length; i++) {
            pp = new ParsePosition(0);
            Object[] parsed = null;

            try {
                MessageFormat mf = new MessageFormat(patterns[i]);
                Format[] formats = mf.getFormats();
                for (int j=0; j < formats.length; j++) {
                    ((DecimalFormat)formats[j]).setParseBigDecimal(true);
                    ((DecimalFormat)formats[j]).setParseIntegerOnly(true);
                }

                parsed = mf.parse(from[i], pp);

                if (pp.getErrorIndex() != parsePosition2[i][0]) {
                    errln("Case" + (i+1) +
                          ": getErrorIndex() returns wrong value. expected:" +
                          parsePosition2[i][0] + ", got:"+ pp.getErrorIndex() +
                          " for " + from[i]);
                }
                if (pp.getIndex() != parsePosition2[i][1]) {
                    errln("Case" + (i+1) +
                          ": getIndex() returns wrong value. expected:" +
                          parsePosition2[i][1] + ", got:"+ pp.getIndex() +
                          " for " + from[i]);
                }
            }
            catch(Exception e) {
                errln("Unexpected exception: " + e.getMessage());
            }

            if (parsePosition2[i][0] == -1) {
                checkType(from[i], getType(new BigDecimal(expected2[i])),
                          getType((Number)parsed[0]));
                checkParse(from[i], new BigDecimal(expected2[i]),
                           (Number)parsed[0]);
            }
        }
    }

    static final String[] from3 = {
        "12,345,678,901,234,567,890.98765432109876543210987654321",
        "-12,345,678,901,234,567,890.98765432109876543210987654321",
        "9,876,543,210,987,654,321,098,765,432,109,876,543,210",
        "-9,876,543,210,987,654,321,098,765,432,109,876,543,210",
        "1234556790000E-8",
    };
    static final String[] expected3 = {
        "12345678901234567890",
        "-12345678901234567890",
        "9876543210987654321098765432109876543210",
        "-9876543210987654321098765432109876543210",
        "12345.56790000",
    };
    static final int[][] parsePosition3 = {     // {errorIndex, index}
        {-1, 26},
        {-1, 27},
        {-1, 53},
        {-1, 54},
        {-1, 16},
    };

    /**
     * Test for DecimalFormat: setParseIntegerOnly(true)
     */
    void test_Parse_in_DecimalFormat_ParseIntegerOnly() {
        DecimalFormat df = (DecimalFormat)NumberFormat.getIntegerInstance();
        df.setParseBigDecimal(true);

        for (int i=0; i < from3.length; i++) {
            pp = new ParsePosition(0);
            Number parsed = null;

            try {
                parsed = df.parse(from3[i], pp);

                if (pp.getErrorIndex() != parsePosition3[i][0]) {
                    errln("Case" + (i+1) +
                          ": getErrorIndex() returns wrong value. expected:" +
                          parsePosition3[i][0] + ", got:"+ pp.getErrorIndex() +
                          " for " + from3[i]);
                }
                if (pp.getIndex() != parsePosition3[i][1]) {
                    errln("Case" + (i+1) +
                          ": getIndex() returns wrong value. expected:" +
                          parsePosition3[i][1] + ", got:"+ pp.getIndex() +
                          " for " + from3[i]);
                }
            }
            catch(Exception e) {
                errln("Unexpected exception: " + e.getMessage());
            }

            if (parsePosition3[i][0] == -1) {
                checkType(from3[i], getType(new BigDecimal(expected3[i])),
                          getType(parsed));
                checkParse(from3[i], new BigDecimal(expected3[i]), parsed);
            }
        }
    }

    protected void check(String from, Number to) {
        pp = new ParsePosition(0);
        try {
            parsed = df.parse(from, pp);
        }
        catch(Exception e) {
            exceptionOccurred = true;
            errln(e.getMessage());
        }
        if (!exceptionOccurred) {
            checkParse(from, to, parsed);
            checkType(from, getType(to), getType(parsed));
            checkParsePosition(from, from.length(), pp.getIndex());
        }
    }

    private void checkParse(String orig, Number expected, Number got) {
        if (!expected.equals(got)) {
            errln("Parsing... failed." +
                  "\n   original: " + orig +
                  "\n   parsed:   " + got +
                  "\n   expected: " + expected + "\n");
        }
    }

    private void checkType(String orig, String expected, String got) {
        if (!expected.equals(got)) {
            errln("Parsing... unexpected Class returned." +
                  "\n   original: " + orig +
                  "\n   got:      " + got +
                  "\n   expected: " + expected + "\n");
        }
    }

    private void checkParsePosition(String orig, int expected, int got) {
        if (expected != got) {
            errln("Parsing... wrong ParsePosition returned." +
                  "\n   original: " + orig +
                  "\n   got:      " + got +
                  "\n   expected: " + expected + "\n");
        }
    }

    private String getType(Number number) {
        return number.getClass().getName();
    }
}