/*

 * Copyright (c) 1997, 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 4052223 4059870 4061302 4062486 4066646 4068693 4070798 4071005 4071014

 * 4071492 4071859 4074454 4074620 4075713 4083018 4086575 4087244 4087245

 * 4087251 4087535 4088161 4088503 4090489 4090504 4092480 4092561 4095713

 * 4098741 4099404 4101481 4106658 4106662 4106664 4108738 4110936 4122840

 * 4125885 4134034 4134300 4140009 4141750 4145457 4147295 4147706 4162198

 * 4162852 4167494 4170798 4176114 4179818 4185761 4212072 4212073 4216742

 * 4217661 4243011 4243108 4330377 4233840 4241880 4833877 8008577

 * @summary Regression tests for NumberFormat and associated classes

 * @library /java/text/testlib

 * @modules java.base/sun.util.resources

 * @compile -XDignore.symbol.file NumberRegression.java

 * @run main/othervm -Djava.locale.providers=COMPAT,SPI NumberRegression

 */

/*

(C) Copyright Taligent, Inc. 1996 - All Rights Reserved

(C) Copyright IBM Corp. 1996 - All Rights Reserved

  The original version of this source code and documentation is copyrighted and

owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These materials are

provided under terms of a License Agreement between Taligent and Sun. This

technology is protected by multiple US and International patents. This notice and

attribution to Taligent may not be removed.

  Taligent is a registered trademark of Taligent, Inc.

*/

import java.text.*;

import java.util.*;

import java.math.BigDecimal;

import java.io.*;

import java.math.BigInteger;

import sun.util.resources.LocaleData;

public class NumberRegression extends IntlTest {

    public static void main(String[] args) throws Exception {

        new NumberRegression().run(args);

    }

    /**

     * NumberFormat.equals comparing with null should always return false.

     */

    public void Test4075713(){

        try {

            MyNumberFormatTest tmp = new MyNumberFormatTest();

            if (!tmp.equals(null))

                logln("NumberFormat.equals passed");

        } catch (NullPointerException e) {

            errln("(new MyNumberFormatTest()).equals(null) throws unexpected exception");

        }

    }

    /**

     * NumberFormat.equals comparing two obj equal even the setGroupingUsed

     * flag is different.

     */

    public void Test4074620() {

        MyNumberFormatTest nf1 = new MyNumberFormatTest();

        MyNumberFormatTest nf2 = new MyNumberFormatTest();

        nf1.setGroupingUsed(false);

        nf2.setGroupingUsed(true);

        if (nf1.equals(nf2)) errln("Test for bug 4074620 failed");

        else logln("Test for bug 4074620 passed.");

        return;

    }

    /**

     * DecimalFormat.format() incorrectly uses maxFractionDigits setting.

     */

    public void Test4088161 (){

        DecimalFormat df = new DecimalFormat();

        double d = 100;

        df.setMinimumFractionDigits(0);

        df.setMaximumFractionDigits(16);

        StringBuffer sBuf1 = new StringBuffer("");

        FieldPosition fp1 = new FieldPosition(0);

        logln("d = " + d);

        logln("maxFractionDigits = " + df.getMaximumFractionDigits());

        logln(" format(d) = '" + df.format(d, sBuf1, fp1) + "'");

        df.setMaximumFractionDigits(17);

        StringBuffer sBuf2 = new StringBuffer("");

        FieldPosition fp2 = new FieldPosition(0);

        logln("maxFractionDigits = " + df.getMaximumFractionDigits());

        df.format(d, sBuf2, fp2);

        if (!sBuf2.toString().equals(expected))

            errln(" format(d) = '" + sBuf2 + "'");

    }

    /**

     * DecimalFormatSymbols should be cloned in the ctor DecimalFormat.

     * DecimalFormat(String, DecimalFormatSymbols).

     */

    public void Test4087245 (){

        DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance();

        DecimalFormat df = new DecimalFormat("#,##0.0", symbols);

        long n = 123;

        StringBuffer buf1 = new StringBuffer();

        StringBuffer buf2 = new StringBuffer();

        logln("format(" + n + ") = " +

        df.format(n, buf1, new FieldPosition(0)));

        symbols.setDecimalSeparator('p'); // change value of field

        logln("format(" + n + ") = " +

        df.format(n, buf2, new FieldPosition(0)));

        if (!buf1.toString().equals(buf2.toString()))

            errln("Test for bug 4087245 failed");

    }

    /**

     * DecimalFormat.format() incorrectly formats 0.0

     */

    public void Test4087535 ()

    {

        DecimalFormat df = new DecimalFormat();

        df.setMinimumIntegerDigits(0);

        double n = 0;

        String buffer = new String();

        buffer = df.format(n);

        if (buffer.length() == 0)

            errln(n + ": '" + buffer + "'");

        n = 0.1;

        buffer = df.format(n);

        if (buffer.length() == 0)

            errln(n + ": '" + buffer + "'");

    }

    /**

     * DecimalFormat.format fails when groupingSize is set to 0.

     */

    public void Test4088503 (){

        DecimalFormat df = new DecimalFormat();

        df.setGroupingSize(0);

        StringBuffer sBuf = new StringBuffer("");

        FieldPosition fp = new FieldPosition(0);

        try {

            logln(df.format(123, sBuf, fp).toString());

        } catch (Exception foo) {

            errln("Test for bug 4088503 failed.");

        }

    }

    /**

     * NumberFormat.getCurrencyInstance is wrong.

     */

    public void Test4066646 () {

        float returnfloat = 0.0f;

        assignFloatValue(2.04f);

        assignFloatValue(2.03f);

        assignFloatValue(2.02f);

        assignFloatValue(0.0f);

    }

    public float assignFloatValue(float returnfloat)

    {

        logln(" VALUE " + returnfloat);

        NumberFormat nfcommon =  NumberFormat.getCurrencyInstance(Locale.US);

        nfcommon.setGroupingUsed(false);

        String stringValue = nfcommon.format(returnfloat).substring(1);

        if (Float.valueOf(stringValue).floatValue() != returnfloat)

            errln(" DISPLAYVALUE " + stringValue);

        return returnfloat;

    } // End Of assignFloatValue()

    /**

     * DecimalFormat throws exception when parsing "0"

     */

    public void Test4059870() {

        DecimalFormat format = new DecimalFormat("00");

        try {

            logln(format.parse("0").toString());

        } catch (Exception e) { errln("Test for bug 4059870 failed : " + e); }

    }

    /**

     * DecimalFormatSymbol.equals should always return false when

     * comparing with null.

     */

    public void Test4083018 (){

        DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance();

        try {

            if (!dfs.equals(null))

                logln("Test Passed!");

        } catch (Exception foo) {

            errln("Test for bug 4083018 failed => Message : " + foo.getMessage());

        }

    }

    /**

     * DecimalFormat does not round up correctly.

     */

    public void Test4071492 (){

        Locale savedLocale = Locale.getDefault();

        Locale.setDefault(Locale.US);

        double x = 0.00159999;

        NumberFormat nf = NumberFormat.getInstance();

        nf.setMaximumFractionDigits(4);

        String out = nf.format(x);

        logln("0.00159999 formats with 4 fractional digits to " + out);

        String expected = "0.0016";

        if (!out.equals(expected))

            errln("FAIL: Expected " + expected);

        Locale.setDefault(savedLocale);

    }

    /**

     * A space as a group separator for localized pattern causes

     * wrong format.  WorkAround : use non-breaking space.

     */

    public void Test4086575() {

        NumberFormat nf = NumberFormat.getInstance(Locale.FRANCE);

        logln("nf toPattern1: " + ((DecimalFormat)nf).toPattern());

        logln("nf toLocPattern1: " + ((DecimalFormat)nf).toLocalizedPattern());

        // No group separator

        logln("...applyLocalizedPattern ###,00;(###,00) ");

        ((DecimalFormat)nf).applyLocalizedPattern("###,00;(###,00)");

        logln("nf toPattern2: " + ((DecimalFormat)nf).toPattern());

        logln("nf toLocPattern2: " + ((DecimalFormat)nf).toLocalizedPattern());

        logln("nf: " + nf.format(1234)); // 1234,00

        logln("nf: " + nf.format(-1234)); // (1234,00)

        // Space as group separator

        logln("...applyLocalizedPattern # ###,00;(# ###,00) ");

        ((DecimalFormat)nf).applyLocalizedPattern("#\u00a0###,00;(#\u00a0###,00)");

        logln("nf toPattern2: " + ((DecimalFormat)nf).toPattern());

        logln("nf toLocPattern2: " + ((DecimalFormat)nf).toLocalizedPattern());

        String buffer = nf.format(1234);

        if (!buffer.equals("1\u00a0234,00"))

            errln("nf : " + buffer); // Expect 1 234,00

        buffer = nf.format(-1234);

        if (!buffer.equals("(1\u00a0234,00)"))

            errln("nf : " + buffer); // Expect (1 234,00)

        // Erroneously prints:

        // 1234,00 ,

        // (1234,00 ,)

    }

    /**

     * DecimalFormat.parse returns wrong value

     */

    public void Test4068693()

    {

        Locale savedLocale = Locale.getDefault();

        Locale.setDefault(Locale.US);

        logln("----- Test Application -----");

        ParsePosition pos;

        DecimalFormat df = new DecimalFormat();

        Double d = (Double)df.parse("123.55456", pos=new ParsePosition(0));

        if (!d.toString().equals("123.55456")) {

            errln("Result -> " + d.doubleValue());

        }

        Locale.setDefault(savedLocale);

    }

    /* bugs 4069754, 4067878

     * null pointer thrown when accessing a deserialized DecimalFormat

     * object.

     */

    public void Test4069754()

    {

        try {

            myformat it = new myformat();

            logln(it.Now());

            FileOutputStream ostream = new FileOutputStream("t.tmp");

            ObjectOutputStream p = new ObjectOutputStream(ostream);

            p.writeObject(it);

            ostream.close();

            logln("Saved ok.");

            FileInputStream istream = new FileInputStream("t.tmp");

            ObjectInputStream p2 = new ObjectInputStream(istream);

            myformat it2 = (myformat)p2.readObject();

            logln(it2.Now());

            istream.close();

            logln("Loaded ok.");

        } catch (Exception foo) {

            errln("Test for bug 4069754 or 4057878 failed => Exception: " + foo.getMessage());

        }

    }

    /**

     * DecimalFormat.applyPattern(String) allows illegal patterns

     */

    public void Test4087251 (){

        DecimalFormat df = new DecimalFormat();

        try {

            df.applyPattern("#.#.#");

            logln("toPattern() returns \"" + df.toPattern() + "\"");

            errln("applyPattern(\"#.#.#\") doesn't throw IllegalArgumentException");

        } catch (IllegalArgumentException e) {

            logln("Caught Illegal Argument Error !");

        }

        // Second test; added 5/11/98 when reported to fail on 1.2b3

        try {

            df.applyPattern("#0.0#0#0");

            logln("toPattern() returns \"" + df.toPattern() + "\"");

            errln("applyPattern(\"#0.0#0#0\") doesn't throw IllegalArgumentException");

        } catch (IllegalArgumentException e) {

            logln("Ok - IllegalArgumentException for #0.0#0#0");

        }

    }

    /**

     * DecimalFormat.format() loses precision

     */

    public void Test4090489 (){

        Locale savedLocale = Locale.getDefault();

        Locale.setDefault(Locale.US);

        DecimalFormat df = new DecimalFormat();

        df.setMinimumFractionDigits(10);

        df.setGroupingUsed(false);

        double d = 1.000000000000001E7;

        BigDecimal bd = new BigDecimal(d);

        StringBuffer sb = new StringBuffer("");

        FieldPosition fp = new FieldPosition(0);

        logln("d = " + d);

        logln("BigDecimal.toString():  " + bd.toString());

        df.format(d, sb, fp);

        if (!sb.toString().equals("10000000.0000000100")) {

            errln("DecimalFormat.format(): " + sb.toString());

        }

        Locale.setDefault(savedLocale);

    }

    /**

     * DecimalFormat.format() loses precision

     */

    public void Test4090504 ()

    {

        double d = 1;

        logln("d = " + d);

        DecimalFormat df = new DecimalFormat();

        StringBuffer sb;

        FieldPosition fp;

        try {

            for (int i = 17; i <= 20; i++) {

                df.setMaximumFractionDigits(i);

                sb = new StringBuffer("");

                fp = new FieldPosition(0);

                logln("  getMaximumFractionDigits() = " + i);

                logln("  formated: " + df.format(d, sb, fp));

            }

        } catch (Exception foo) {

            errln("Bug 4090504 regression test failed. Message : " + foo.getMessage());

        }

    }

    /**

     * DecimalFormat.parse(String str, ParsePosition pp) loses precision

     */

    public void Test4095713 ()

    {

        Locale savedLocale = Locale.getDefault();

        Locale.setDefault(Locale.US);

        DecimalFormat df = new DecimalFormat();

        String str = "0.1234";

        Double d1 = new Double(str);

        Double d2 = (Double) df.parse(str, new ParsePosition(0));

        logln(d1.toString());

        if (d2.doubleValue() != d1.doubleValue())

            errln("Bug 4095713 test failed, new double value : " + d2.doubleValue());

        Locale.setDefault(savedLocale);

    }

    /**

     * DecimalFormat.parse() fails when multiplier is not set to 1

     */

    public void Test4092561 ()

    {

        Locale savedLocale = Locale.getDefault();

        Locale.setDefault(Locale.US);

        DecimalFormat df = new DecimalFormat();

        String str = Long.toString(Long.MIN_VALUE);

        logln("Long.MIN_VALUE : " + df.parse(str, new ParsePosition(0)).toString());

        df.setMultiplier(100);

        Number num = df.parse(str, new ParsePosition(0));

        if (num.doubleValue() != -9.223372036854776E16) {

            errln("Bug 4092561 test failed when multiplier is not set to 1. Expected: -9.223372036854776E16, got: " + num.doubleValue());

        }

        df.setMultiplier(-100);

        num = df.parse(str, new ParsePosition(0));

        if (num.doubleValue() != 9.223372036854776E16) {

            errln("Bug 4092561 test failed when multiplier is not set to 1. Expected: 9.223372036854776E16, got: " + num.doubleValue());

        }

        str = Long.toString(Long.MAX_VALUE);

        logln("Long.MAX_VALUE : " + df.parse(str, new ParsePosition(0)).toString());

        df.setMultiplier(100);

        num = df.parse(str, new ParsePosition(0));

        if (num.doubleValue() != 9.223372036854776E16) {

            errln("Bug 4092561 test failed when multiplier is not set to 1. Expected: 9.223372036854776E16, got: " + num.doubleValue());

        }

        df.setMultiplier(-100);

        num = df.parse(str, new ParsePosition(0));

        if (num.doubleValue() != -9.223372036854776E16) {

            errln("Bug 4092561 test failed when multiplier is not set to 1. Expected: -9.223372036854776E16, got: " + num.doubleValue());

        }

        Locale.setDefault(savedLocale);

    }

    /**

     * DecimalFormat: Negative format ignored.

     */

    public void Test4092480 ()

    {

        DecimalFormat dfFoo = new DecimalFormat("000");

        try {

            dfFoo.applyPattern("0000;-000");

            if (!dfFoo.toPattern().equals("#0000"))

                errln("dfFoo.toPattern : " + dfFoo.toPattern());

            logln(dfFoo.format(42));

            logln(dfFoo.format(-42));

            dfFoo.applyPattern("000;-000");

            if (!dfFoo.toPattern().equals("#000"))

                errln("dfFoo.toPattern : " + dfFoo.toPattern());

            logln(dfFoo.format(42));

            logln(dfFoo.format(-42));

            dfFoo.applyPattern("000;-0000");

            if (!dfFoo.toPattern().equals("#000"))

                errln("dfFoo.toPattern : " + dfFoo.toPattern());

            logln(dfFoo.format(42));

            logln(dfFoo.format(-42));

            dfFoo.applyPattern("0000;-000");

            if (!dfFoo.toPattern().equals("#0000"))

                errln("dfFoo.toPattern : " + dfFoo.toPattern());

            logln(dfFoo.format(42));

            logln(dfFoo.format(-42));

        } catch (Exception foo) {

            errln("Message " + foo.getMessage());

        }

    }

    /**

     * NumberFormat.getCurrencyInstance() produces format that uses

     * decimal separator instead of monetary decimal separator.

     *

     * Rewrote this test not to depend on the actual pattern.  Pattern should

     * never contain the monetary separator!  Decimal separator in pattern is

     * interpreted as monetary separator if currency symbol is seen!

     */

    public void Test4087244 () {

        Locale de = new Locale("pt", "PT");

        DecimalFormat df = (DecimalFormat) NumberFormat.getCurrencyInstance(de);

        DecimalFormatSymbols sym = df.getDecimalFormatSymbols();

        sym.setMonetaryDecimalSeparator('$');

        df.setDecimalFormatSymbols(sym);

        char decSep = sym.getDecimalSeparator();

        char monSep = sym.getMonetaryDecimalSeparator();

        char zero = sym.getZeroDigit();

        if (decSep == monSep) {

            errln("ERROR in test: want decimal sep != monetary sep");

        } else {

            df.setMinimumIntegerDigits(1);

            df.setMinimumFractionDigits(2);

            String str = df.format(1.23);

            String monStr = "1" + monSep + "23";

            String decStr = "1" + decSep + "23";

            if (str.indexOf(monStr) >= 0 && str.indexOf(decStr) < 0) {

                logln("OK: 1.23 -> \"" + str + "\" contains \"" +

                      monStr + "\" and not \"" + decStr + '"');

            } else {

                errln("FAIL: 1.23 -> \"" + str + "\", should contain \"" +

                      monStr +

                      "\" and not \"" + decStr + '"');

            }

        }

    }

    /**

     * Number format data rounding errors for locale FR

     */

    public void Test4070798 () {

        NumberFormat formatter;

        String tempString;

        /* User error :

        String expectedDefault = "-5\u00a0789,987";

        String expectedCurrency = "5\u00a0789,98 F";

        String expectedPercent = "-578\u00a0998%";

        */

        String expectedDefault = "-5\u00a0789,988";

        String expectedCurrency = "5\u00a0789,99 \u20AC";

        // changed for bug 6547501