/*
 * Copyright (c) 2018, 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 8177552
 * @summary Checks the rounding of formatted number in compact number formatting
 * @run testng/othervm CNFRoundingTest
 */

import java.math.RoundingMode;
import java.text.NumberFormat;
import java.util.Locale;
import static org.testng.Assert.*;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class CNFRoundingTest {

    @DataProvider(name = "roundingData")
    Object[][] roundingData() {
        return new Object[][]{
            {5500, "6K", "6K", "5K", "6K", "5K", "6K", "5K"},
            {2500, "2K", "3K", "2K", "3K", "2K", "3K", "2K"},
            {1600, "2K", "2K", "2K", "2K", "1K", "2K", "1K"},
            {1100, "1K", "1K", "1K", "2K", "1K", "2K", "1K"},
            {1000, "1K", "1K", "1K", "1K", "1K", "1K", "1K"},
            {-1000, "-1K", "-1K", "-1K", "-1K", "-1K", "-1K", "-1K"},
            {-1100, "-1K", "-1K", "-1K", "-2K", "-1K", "-1K", "-2K"},
            {-1600, "-2K", "-2K", "-2K", "-2K", "-1K", "-1K", "-2K"},
            {-2500, "-2K", "-3K", "-2K", "-3K", "-2K", "-2K", "-3K"},
            {-5500, "-6K", "-6K", "-5K", "-6K", "-5K", "-5K", "-6K"},
            {5501, "6K", "6K", "6K", "6K", "5K", "6K", "5K"},
            {-5501, "-6K", "-6K", "-6K", "-6K", "-5K", "-5K", "-6K"},
            {1001, "1K", "1K", "1K", "2K", "1K", "2K", "1K"},
            {-1001, "-1K", "-1K", "-1K", "-2K", "-1K", "-1K", "-2K"},
            {4501, "5K", "5K", "5K", "5K", "4K", "5K", "4K"},
            {-4501, "-5K", "-5K", "-5K", "-5K", "-4K", "-4K", "-5K"},
            {4500, "4K", "5K", "4K", "5K", "4K", "5K", "4K"},
            {-4500, "-4K", "-5K", "-4K", "-5K", "-4K", "-4K", "-5K"},};
    }

    @DataProvider(name = "roundingFract")
    Object[][] roundingFract() {
        return new Object[][]{
            {5550, "5.5K", "5.5K", "5.5K", "5.6K", "5.5K", "5.6K", "5.5K"},
            {2550, "2.5K", "2.5K", "2.5K", "2.6K", "2.5K", "2.6K", "2.5K"},
            {1660, "1.7K", "1.7K", "1.7K", "1.7K", "1.6K", "1.7K", "1.6K"},
            {1110, "1.1K", "1.1K", "1.1K", "1.2K", "1.1K", "1.2K", "1.1K"},
            {1000, "1.0K", "1.0K", "1.0K", "1.0K", "1.0K", "1.0K", "1.0K"},
            {-1000, "-1.0K", "-1.0K", "-1.0K", "-1.0K", "-1.0K", "-1.0K", "-1.0K"},
            {-1110, "-1.1K", "-1.1K", "-1.1K", "-1.2K", "-1.1K", "-1.1K", "-1.2K"},
            {-1660, "-1.7K", "-1.7K", "-1.7K", "-1.7K", "-1.6K", "-1.6K", "-1.7K"},
            {-2550, "-2.5K", "-2.5K", "-2.5K", "-2.6K", "-2.5K", "-2.5K", "-2.6K"},
            {-5550, "-5.5K", "-5.5K", "-5.5K", "-5.6K", "-5.5K", "-5.5K", "-5.6K"},
            {5551, "5.6K", "5.6K", "5.6K", "5.6K", "5.5K", "5.6K", "5.5K"},
            {-5551, "-5.6K", "-5.6K", "-5.6K", "-5.6K", "-5.5K", "-5.5K", "-5.6K"},
            {1001, "1.0K", "1.0K", "1.0K", "1.1K", "1.0K", "1.1K", "1.0K"},
            {-1001, "-1.0K", "-1.0K", "-1.0K", "-1.1K", "-1.0K", "-1.0K", "-1.1K"},
            {4551, "4.6K", "4.6K", "4.6K", "4.6K", "4.5K", "4.6K", "4.5K"},
            {-4551, "-4.6K", "-4.6K", "-4.6K", "-4.6K", "-4.5K", "-4.5K", "-4.6K"},
            {4500, "4.5K", "4.5K", "4.5K", "4.5K", "4.5K", "4.5K", "4.5K"},
            {-4500, "-4.5K", "-4.5K", "-4.5K", "-4.5K", "-4.5K", "-4.5K", "-4.5K"},};
    }

    @DataProvider(name = "rounding2Fract")
    Object[][] rounding2Fract() {
        return new Object[][]{
            {1115, "1.11K", "1.11K", "1.11K"},
            {1125, "1.12K", "1.13K", "1.12K"},
            {1135, "1.14K", "1.14K", "1.14K"},
            {3115, "3.12K", "3.12K", "3.12K"},
            {3125, "3.12K", "3.13K", "3.12K"},
            {3135, "3.13K", "3.13K", "3.13K"},
            {6865, "6.87K", "6.87K", "6.87K"},
            {6875, "6.88K", "6.88K", "6.87K"},
            {6885, "6.88K", "6.88K", "6.88K"},
            {3124, "3.12K", "3.12K", "3.12K"},
            {3126, "3.13K", "3.13K", "3.13K"},
            {3128, "3.13K", "3.13K", "3.13K"},
            {6864, "6.86K", "6.86K", "6.86K"},
            {6865, "6.87K", "6.87K", "6.87K"},
            {6868, "6.87K", "6.87K", "6.87K"},
            {4685, "4.68K", "4.68K", "4.68K"},
            {4687, "4.69K", "4.69K", "4.69K"},
            {4686, "4.69K", "4.69K", "4.69K"},};
    }

    @Test(expectedExceptions = NullPointerException.class)
    public void testNullMode() {
        NumberFormat fmt = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
        fmt.setRoundingMode(null);
    }

    @Test(dataProvider = "roundingData")
    public void testRounding(Object number, String halfEven, String halfUp,
            String halfDown, String up, String down, String ceiling, String floor) {
        testHalfEven(number, halfEven, 0);
        testHalfUp(number, halfUp, 0);
        testHalfDown(number, halfDown, 0);
        testUp(number, up, 0);
        testDown(number, down, 0);
        testCeiling(number, ceiling, 0);
        testFloor(number, floor, 0);
    }

    @Test(dataProvider = "roundingFract")
    public void testRoundingFract(Object number, String halfEven, String halfUp,
            String halfDown, String up, String down, String ceiling, String floor) {
        testHalfEven(number, halfEven, 1);
        testHalfUp(number, halfUp, 1);
        testHalfDown(number, halfDown, 1);
        testUp(number, up, 1);
        testDown(number, down, 1);
        testCeiling(number, ceiling, 1);
        testFloor(number, floor, 1);
    }

    @Test(dataProvider = "rounding2Fract")
    public void testRounding2Fract(Object number, String halfEven, String halfUp,
            String halfDown) {
        testHalfEven(number, halfEven, 2);
        testHalfUp(number, halfUp, 2);
        testHalfDown(number, halfDown, 2);
    }

    private void testHalfEven(Object number, String halfEven, int fraction) {
        NumberFormat fmtHalfEven = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);

        if (fmtHalfEven.getRoundingMode() != RoundingMode.HALF_EVEN) {
            throw new RuntimeException("[FAILED: Default rounding should be"
                    + " HALF_EVEN]");
        }
        fmtHalfEven.setMinimumFractionDigits(fraction);
        String result = fmtHalfEven.format(number);
        if (!result.equals(halfEven)) {
            assertEquals(result, halfEven, "FAILED: Incorrect formatting"
                    + " of number " + number + " using rounding mode: "
                    + RoundingMode.HALF_EVEN);
        }
    }

    private void testHalfUp(Object number, String halfUp, int fraction) {
        NumberFormat fmtHalfUp = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
        fmtHalfUp.setRoundingMode(RoundingMode.HALF_UP);
        if (fmtHalfUp.getRoundingMode() != RoundingMode.HALF_UP) {
            throw new RuntimeException("[FAILED: RoundingMode set is not"
                    + " returned by getRoundingMode]");
        }
        fmtHalfUp.setMinimumFractionDigits(fraction);
        String result = fmtHalfUp.format(number);
        if (!result.equals(halfUp)) {
            assertEquals(result, halfUp, "FAILED: Incorrect formatting"
                    + " of number " + number + " using rounding mode: "
                    + RoundingMode.HALF_UP);
        }
    }

    private void testHalfDown(Object number, String halfDown, int fraction) {
        NumberFormat fmtHalfDown = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);

        fmtHalfDown.setRoundingMode(RoundingMode.HALF_DOWN);
        if (fmtHalfDown.getRoundingMode() != RoundingMode.HALF_DOWN) {
            throw new RuntimeException("[FAILED: RoundingMode set is not"
                    + " returned by getRoundingMode]");
        }
        fmtHalfDown.setMinimumFractionDigits(fraction);
        String result = fmtHalfDown.format(number);
        if (!result.equals(halfDown)) {
            assertEquals(result, halfDown, "FAILED: Incorrect formatting"
                    + " of number " + number + " using rounding mode: "
                    + RoundingMode.HALF_DOWN);
        }
    }

    private void testUp(Object number, String up, int fraction) {
        NumberFormat fmtUp = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
        fmtUp.setRoundingMode(RoundingMode.UP);
        if (fmtUp.getRoundingMode() != RoundingMode.UP) {
            throw new RuntimeException("[FAILED: RoundingMode set is not"
                    + " returned by getRoundingMode]");
        }
        fmtUp.setMinimumFractionDigits(fraction);
        String result = fmtUp.format(number);
        if (!result.equals(up)) {
            assertEquals(result, up, "FAILED: Incorrect formatting"
                    + " of number " + number + " using rounding mode: "
                    + RoundingMode.UP);
        }
    }

    private void testDown(Object number, String down, int fraction) {
        NumberFormat fmtDown = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);

        fmtDown.setRoundingMode(RoundingMode.DOWN);
        if (fmtDown.getRoundingMode() != RoundingMode.DOWN) {
            throw new RuntimeException("[FAILED: RoundingMode set is not"
                    + " returned by getRoundingMode]");
        }
        fmtDown.setMinimumFractionDigits(fraction);
        String result = fmtDown.format(number);
        if (!result.equals(down)) {
            assertEquals(result, down, "FAILED: Incorrect formatting"
                    + " of number " + number + " using rounding mode: "
                    + RoundingMode.DOWN);
        }
    }

    private void testCeiling(Object number, String ceiling, int fraction) {
        NumberFormat fmtCeiling = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
        fmtCeiling.setRoundingMode(RoundingMode.CEILING);
        if (fmtCeiling.getRoundingMode() != RoundingMode.CEILING) {
            throw new RuntimeException("[FAILED: RoundingMode set is not"
                    + " returned by getRoundingMode]");
        }

        fmtCeiling.setMinimumFractionDigits(fraction);
        String result = fmtCeiling.format(number);
        if (!result.equals(ceiling)) {
            assertEquals(result, ceiling, "FAILED: Incorrect formatting"
                    + " of number " + number + " using rounding mode: "
                    + RoundingMode.CEILING);
        }
    }

    private void testFloor(Object number, String floor, int fraction) {
        NumberFormat fmtFloor = NumberFormat
                .getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
        fmtFloor.setRoundingMode(RoundingMode.FLOOR);
        if (fmtFloor.getRoundingMode() != RoundingMode.FLOOR) {
            throw new RuntimeException("[FAILED: RoundingMode set is not"
                    + " returned by getRoundingMode]");
        }
        fmtFloor.setMinimumFractionDigits(fraction);
        String result = fmtFloor.format(number);
        if (!result.equals(floor)) {
            assertEquals(result, floor, "FAILED: Incorrect formatting"
                    + " of number " + number + " using rounding mode: "
                    + RoundingMode.FLOOR);
        }
    }

}