--- /dev/null 2018-10-22 22:34:38.096000000 +0530 +++ new/test/jdk/java/text/Format/CompactNumberFormat/CNFRoundingTest.java 2018-11-16 17:01:18.156934364 +0530 @@ -0,0 +1,269 @@ +/* + * 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); + } + } + +}