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