1 /*
   2  * Copyright (c) 2013, 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 import java.util.Random;
  25 import sun.misc.FloatingDecimal;
  26 
  27 /*
  28 OldFloatingDecimalForTest
  29 
  30 public class OldFloatingDecimalForTest {
  31   public boolean digitsRoundedUp();
  32   public OldFloatingDecimalForTest(double);
  33   public OldFloatingDecimalForTest(float);
  34   public boolean decimalDigitsExact();
  35   public java.lang.String toString();
  36   public java.lang.String toJavaFormatString();
  37   public void appendTo(java.lang.Appendable);
  38   public static OldFloatingDecimalForTest readJavaFormatString(java.lang.String) throws java.lang.NumberFormatException;
  39   public strictfp double doubleValue();
  40   public strictfp float floatValue();
  41 }
  42 
  43 sun.misc.FloatingDecimal
  44 
  45 public class sun.misc.FloatingDecimal {
  46   public sun.misc.FloatingDecimal();
  47   public static java.lang.String toJavaFormatString(double);
  48   public static java.lang.String toJavaFormatString(float);
  49   public static void appendTo(double, java.lang.Appendable);
  50   public static void appendTo(float, java.lang.Appendable);
  51   public static double parseDouble(java.lang.String) throws java.lang.NumberFormatException;
  52   public static float parseFloat(java.lang.String) throws java.lang.NumberFormatException;
  53   public static sun.misc.FloatingDecimal$AbstractD2ABuffer getD2ABuffer(double);
  54 }
  55 */
  56 
  57 /**
  58  * @test
  59  * @bug 7032154
  60  * @summary unit tests of sun.misc.FloatingDecimal



  61  * @author Brian Burkhalter
  62  */
  63 public class TestFloatingDecimal {
  64     private static enum ResultType {
  65         RESULT_EXCEPTION,
  66         RESULT_PRINT
  67     }
  68 
  69     private static final ResultType RESULT_TYPE = ResultType.RESULT_PRINT;
  70     private static final int NUM_RANDOM_TESTS = 100000;
  71 
  72     private static final Random RANDOM = new Random();
  73 
  74     private static void result(String message) {
  75         switch (RESULT_TYPE) {
  76             case RESULT_EXCEPTION:
  77                 throw new RuntimeException(message);
  78             case RESULT_PRINT:
  79                 System.err.println(message);
  80                 break;
  81             default:
  82                 assert false;
  83         }
  84     }
  85 
  86     private static int check(String test, Object expected, Object actual) {
  87         int failures = 0;
  88         if(!actual.equals(expected)) {
  89             failures++;
  90             result("Test "+test+" expected "+expected+" but obtained "+actual);
  91         }
  92         return failures;
  93     }
  94 
  95     private static int testAppendToDouble() {
  96         System.out.println("  testAppendToDouble");
  97         int failures = 0;
  98 
  99         for(int i = 0; i < NUM_RANDOM_TESTS; i++) {
 100             double[] d = new double[] {
 101                 RANDOM.nextLong(),
 102                 RANDOM.nextGaussian(),
 103                 RANDOM.nextDouble()*Double.MAX_VALUE
 104             };
 105             for(int j = 0; j < d.length; j++) {
 106                 OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(d[j]);
 107                 StringBuilder sb = new StringBuilder();
 108                 ofd.appendTo(sb);
 109                 String oldString = sb.toString();
 110                 sb = new StringBuilder();
 111                 FloatingDecimal.appendTo(d[j], sb);
 112                 String newString = sb.toString();
 113                 failures += check("testAppendToDouble", oldString, newString);
 114             }
 115         }
 116 
 117         return failures;
 118     }
 119 
 120     private static int testAppendToFloat() {
 121         System.out.println("  testAppendToFloat");
 122         int failures = 0;
 123 
 124         for(int i = 0; i < NUM_RANDOM_TESTS; i++) {
 125             float[] f = new float[] {
 126                 RANDOM.nextLong(),
 127                 (float)RANDOM.nextGaussian(),
 128                 RANDOM.nextFloat()*Float.MAX_VALUE
 129             };
 130             for(int j = 0; j < f.length; j++) {
 131                 OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(f[j]);
 132                 StringBuilder sb = new StringBuilder();
 133                 ofd.appendTo(sb);
 134                 String oldString = sb.toString();
 135                 sb = new StringBuilder();
 136                 FloatingDecimal.appendTo(f[j], sb);
 137                 String newString = sb.toString();
 138                 failures += check("testAppendToFloat", oldString, newString);
 139             }
 140         }
 141 
 142         return failures;
 143     }
 144 
 145     private static int testAppendTo() {
 146         System.out.println("testAppendTo");
 147         int failures = 0;
 148 
 149         failures += testAppendToDouble();
 150         failures += testAppendToFloat();
 151 
 152         return failures;
 153     }
 154 
 155     private static int testParseDouble() {
 156         System.out.println("  testParseDouble");
 157         int failures = 0;
 158 
 159         for(int i = 0; i < NUM_RANDOM_TESTS; i++) {
 160             double[] d = new double[] {
 161                 RANDOM.nextLong(),
 162                 RANDOM.nextGaussian(),
 163                 RANDOM.nextDouble()*Double.MAX_VALUE
 164             };
 165             for(int j = 0; j < d.length; j++) {
 166                 OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(d[j]);
 167                 String javaFormatString = ofd.toJavaFormatString();
 168                 ofd = OldFloatingDecimalForTest.readJavaFormatString(javaFormatString);
 169                 double oldDouble = ofd.doubleValue();
 170                 double newDouble = FloatingDecimal.parseDouble(javaFormatString);
 171                 failures += check("testParseDouble", oldDouble, newDouble);
 172             }
 173         }
 174 
 175         return failures;
 176     }
 177 
 178     private static int testParseFloat() {
 179         System.out.println("  testParseFloat");
 180         int failures = 0;
 181 
 182         for(int i = 0; i < NUM_RANDOM_TESTS; i++) {
 183             float[] f = new float[] {
 184                 RANDOM.nextInt(),
 185                 (float)RANDOM.nextGaussian(),
 186                 RANDOM.nextFloat()*Float.MAX_VALUE
 187             };
 188             for(int j = 0; j < f.length; j++) {
 189                 OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(f[j]);
 190                 String javaFormatString = ofd.toJavaFormatString();
 191                 ofd = OldFloatingDecimalForTest.readJavaFormatString(javaFormatString);
 192                 float oldFloat = ofd.floatValue();
 193                 float newFloat = FloatingDecimal.parseFloat(javaFormatString);
 194                 failures += check("testParseFloat", oldFloat, newFloat);
 195             }
 196         }
 197 
 198         return failures;
 199     }
 200 
 201     private static int testParse() {
 202         System.out.println("testParse");
 203         int failures = 0;
 204 
 205         failures += testParseDouble();
 206         failures += testParseFloat();
 207 
 208         return failures;
 209     }
 210 
 211     private static int testToJavaFormatStringDoubleFixed() {
 212         System.out.println("    testToJavaFormatStringDoubleFixed");
 213         int failures = 0;
 214 
 215         double[] d = new double [] {
 216             -5.9522650387500933e18, // dtoa() fast path
 217             0.872989018674569,      // dtoa() fast iterative - long
 218             1.1317400099603851e308  // dtoa() slow iterative
 219         };
 220 
 221         for(int i = 0; i < d.length; i++) {
 222             OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(d[i]);
 223             failures += check("testToJavaFormatStringDoubleFixed", ofd.toJavaFormatString(), FloatingDecimal.toJavaFormatString(d[i]));
 224         }
 225 
 226         return failures;
 227     }
 228 
 229     private static int testToJavaFormatStringDoubleRandom() {
 230         System.out.println("    testToJavaFormatStringDoubleRandom");
 231         int failures = 0;
 232 
 233         for(int i = 0; i < NUM_RANDOM_TESTS; i++) {
 234             double[] d = new double[] {
 235                 RANDOM.nextLong(),
 236                 RANDOM.nextGaussian(),
 237                 RANDOM.nextDouble()*Double.MAX_VALUE
 238             };
 239             for(int j = 0; j < d.length; j++) {
 240                 OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(d[j]);
 241                 failures += check("testToJavaFormatStringDoubleRandom", ofd.toJavaFormatString(), FloatingDecimal.toJavaFormatString(d[j]));
 242             }
 243         }
 244 
 245         return failures;
 246     }
 247 
 248     private static int testToJavaFormatStringDouble() {
 249         System.out.println("  testToJavaFormatStringDouble");
 250         int failures = 0;
 251         failures += testToJavaFormatStringDoubleFixed();
 252         failures += testToJavaFormatStringDoubleRandom();
 253         return failures;
 254     }
 255 
 256     private static int testToJavaFormatStringFloatFixed() {
 257         System.out.println("    testToJavaFormatStringFloatFixed");
 258         int failures = 0;
 259 
 260         float[] f = new float[] {
 261             -9.8784166e8f, // dtoa() fast path
 262             0.70443946f,   // dtoa() fast iterative - int
 263             1.8254228e37f  // dtoa() slow iterative
 264         };
 265 
 266         for(int i = 0; i < f.length; i++) {
 267             OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(f[i]);
 268             failures += check("testToJavaFormatStringFloatFixed", ofd.toJavaFormatString(), FloatingDecimal.toJavaFormatString(f[i]));
 269         }
 270 
 271         return failures;
 272     }
 273 
 274     private static int testToJavaFormatStringFloatRandom() {
 275         System.out.println("    testToJavaFormatStringFloatRandom");
 276         int failures = 0;
 277 
 278         for(int i = 0; i < NUM_RANDOM_TESTS; i++) {
 279             float[] f = new float[] {
 280                 RANDOM.nextInt(),
 281                 (float)RANDOM.nextGaussian(),
 282                 RANDOM.nextFloat()*Float.MAX_VALUE
 283             };
 284             for(int j = 0; j < f.length; j++) {
 285                 OldFloatingDecimalForTest ofd = new OldFloatingDecimalForTest(f[j]);
 286                 failures += check("testToJavaFormatStringFloatRandom", ofd.toJavaFormatString(), FloatingDecimal.toJavaFormatString(f[j]));
 287             }
 288         }
 289 
 290         return failures;
 291     }
 292 
 293     private static int testToJavaFormatStringFloat() {
 294         System.out.println("  testToJavaFormatStringFloat");
 295         int failures = 0;
 296 
 297         failures += testToJavaFormatStringFloatFixed();
 298         failures += testToJavaFormatStringFloatRandom();
 299 
 300         return failures;
 301     }
 302 
 303     private static int testToJavaFormatString() {
 304         System.out.println("testToJavaFormatString");
 305         int failures = 0;
 306 
 307         failures += testToJavaFormatStringDouble();
 308         failures += testToJavaFormatStringFloat();
 309 
 310         return failures;
 311     }
 312 
 313     public static void main(String[] args) {
 314         int failures = 0;
 315 
 316         failures += testAppendTo();
 317         failures += testParse();
 318         failures += testToJavaFormatString();
 319 
 320         if (failures != 0) {
 321             throw new RuntimeException("" + failures + " failures while testing FloatingDecimal");
 322         }
 323     }
 324 }
--- EOF ---