1 /* 2 * Copyright (c) 2003, 2011, 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 /* 25 * @test 26 * @bug 4826774 4926547 27 * @summary Tests for {Float, Double}.toHexString methods 28 * @library ../Math 29 * @build DoubleConsts 30 * @run main ToHexString 31 * @author Joseph D. Darcy 32 */ 33 34 package test.java.lang.Double; 35 36 import java.util.regex.*; 37 38 import jdk.internal.math.DoubleConsts; 39 40 public class ToHexString { 41 // Android-changed: JUnit expects exactly one public constructor. 42 // private ToHexString() {} 43 44 /* 45 * Given a double value, create a hexadecimal floating-point 46 * string via an intermediate long hex string. 47 */ doubleToHexString(double d)48 static String doubleToHexString(double d) { 49 return hexLongStringtoHexDoubleString(Long.toHexString(Double.doubleToLongBits(d))); 50 } 51 52 /* 53 * Transform the hexadecimal long output into the equivalent 54 * hexadecimal double value. 55 */ hexLongStringtoHexDoubleString(String transString)56 static String hexLongStringtoHexDoubleString(String transString) { 57 transString = transString.toLowerCase(); 58 59 String zeros = ""; 60 StringBuffer result = new StringBuffer(24); 61 62 for(int i = 0; i < (16 - transString.length()); i++, zeros += "0"); 63 transString = zeros + transString; 64 65 // assert transString.length == 16; 66 67 char topChar; 68 // Extract sign 69 if((topChar=transString.charAt(0)) >= '8' ) {// 8, 9, a, A, b, B, ... 70 result.append("-"); 71 // clear sign bit 72 transString = 73 Character.toString(Character.forDigit(Character.digit(topChar, 16) - 8, 16)) + 74 transString.substring(1,16); 75 } 76 77 // check for NaN and infinity 78 String signifString = transString.substring(3,16); 79 80 if( transString.substring(0,3).equals("7ff") ) { 81 if(signifString.equals("0000000000000")) { 82 result.append("Infinity"); 83 } 84 else 85 result.append("NaN"); 86 } 87 else { // finite value 88 // Extract exponent 89 int exponent = Integer.parseInt(transString.substring(0,3), 16) - 90 DoubleConsts.EXP_BIAS; 91 result.append("0x"); 92 93 if (exponent == Double.MIN_EXPONENT - 1) { // zero or subnormal 94 if(signifString.equals("0000000000000")) { 95 result.append("0.0p0"); 96 } 97 else { 98 result.append("0." + signifString.replaceFirst("0+$", "").replaceFirst("^$", "0") + 99 "p-1022"); 100 } 101 } 102 else { // normal value 103 result.append("1." + signifString.replaceFirst("0+$", "").replaceFirst("^$", "0") + 104 "p" + exponent); 105 } 106 } 107 return result.toString(); 108 } 109 toHexStringTests()110 public static int toHexStringTests() { 111 int failures = 0; 112 String [][] testCases1 = { 113 {"Infinity", "Infinity"}, 114 {"-Infinity", "-Infinity"}, 115 {"NaN", "NaN"}, 116 {"-NaN", "NaN"}, 117 {"0.0", "0x0.0p0"}, 118 {"-0.0", "-0x0.0p0"}, 119 {"1.0", "0x1.0p0"}, 120 {"-1.0", "-0x1.0p0"}, 121 {"2.0", "0x1.0p1"}, 122 {"3.0", "0x1.8p1"}, 123 {"0.5", "0x1.0p-1"}, 124 {"0.25", "0x1.0p-2"}, 125 {"1.7976931348623157e+308", "0x1.fffffffffffffp1023"}, // MAX_VALUE 126 {"2.2250738585072014E-308", "0x1.0p-1022"}, // MIN_NORMAL 127 {"2.225073858507201E-308", "0x0.fffffffffffffp-1022"}, // MAX_SUBNORMAL 128 {"4.9e-324", "0x0.0000000000001p-1022"} // MIN_VALUE 129 }; 130 131 // Compare decimal string -> double -> hex string to hex string 132 for (int i = 0; i < testCases1.length; i++) { 133 String result; 134 if(! (result=Double.toHexString(Double.parseDouble(testCases1[i][0]))). 135 equals(testCases1[i][1])) { 136 failures ++; 137 System.err.println("For floating-point string " + testCases1[i][0] + 138 ", expected hex output " + testCases1[i][1] + ", got " + result +"."); 139 } 140 } 141 142 143 // Except for float subnormals, the output for numerically 144 // equal float and double values should be the same. 145 // Therefore, we will explicitly test float subnormal values. 146 String [][] floatTestCases = { 147 {"Infinity", "Infinity"}, 148 {"-Infinity", "-Infinity"}, 149 {"NaN", "NaN"}, 150 {"-NaN", "NaN"}, 151 {"0.0", "0x0.0p0"}, 152 {"-0.0", "-0x0.0p0"}, 153 {"1.0", "0x1.0p0"}, 154 {"-1.0", "-0x1.0p0"}, 155 {"2.0", "0x1.0p1"}, 156 {"3.0", "0x1.8p1"}, 157 {"0.5", "0x1.0p-1"}, 158 {"0.25", "0x1.0p-2"}, 159 {"3.4028235e+38f", "0x1.fffffep127"}, // MAX_VALUE 160 {"1.17549435E-38f", "0x1.0p-126"}, // MIN_NORMAL 161 {"1.1754942E-38", "0x0.fffffep-126"}, // MAX_SUBNORMAL 162 {"1.4e-45f", "0x0.000002p-126"} // MIN_VALUE 163 }; 164 // Compare decimal string -> double -> hex string to hex string 165 for (int i = 0; i < floatTestCases.length; i++) { 166 String result; 167 if(! (result=Float.toHexString(Float.parseFloat(floatTestCases[i][0]))). 168 equals(floatTestCases[i][1])) { 169 failures++; 170 System.err.println("For floating-point string " + floatTestCases[i][0] + 171 ", expected hex output\n" + floatTestCases[i][1] + ", got\n" + result +"."); 172 } 173 } 174 175 // Particular floating-point values and hex equivalents, mostly 176 // taken from fdlibm source. 177 String [][] testCases2 = { 178 {"+0.0", "0000000000000000"}, 179 {"-0.0", "8000000000000000"}, 180 {"+4.9e-324", "0000000000000001"}, 181 {"-4.9e-324", "8000000000000001"}, 182 183 // fdlibm k_sin.c 184 {"+5.00000000000000000000e-01", "3FE0000000000000"}, 185 {"-1.66666666666666324348e-01", "BFC5555555555549"}, 186 {"+8.33333333332248946124e-03", "3F8111111110F8A6"}, 187 {"-1.98412698298579493134e-04", "BF2A01A019C161D5"}, 188 {"+2.75573137070700676789e-06", "3EC71DE357B1FE7D"}, 189 {"-2.50507602534068634195e-08", "BE5AE5E68A2B9CEB"}, 190 {"+1.58969099521155010221e-10", "3DE5D93A5ACFD57C"}, 191 192 // fdlibm k_cos.c 193 {"+4.16666666666666019037e-02", "3FA555555555554C"}, 194 {"-1.38888888888741095749e-03", "BF56C16C16C15177"}, 195 {"+2.48015872894767294178e-05", "3EFA01A019CB1590"}, 196 {"-2.75573143513906633035e-07", "BE927E4F809C52AD"}, 197 {"+2.08757232129817482790e-09", "3E21EE9EBDB4B1C4"}, 198 {"-1.13596475577881948265e-11", "BDA8FAE9BE8838D4"}, 199 200 // fdlibm e_rempio.c 201 {"1.67772160000000000000e+07", "4170000000000000"}, 202 {"6.36619772367581382433e-01", "3FE45F306DC9C883"}, 203 {"1.57079632673412561417e+00", "3FF921FB54400000"}, 204 {"6.07710050650619224932e-11", "3DD0B4611A626331"}, 205 {"6.07710050630396597660e-11", "3DD0B4611A600000"}, 206 {"2.02226624879595063154e-21", "3BA3198A2E037073"}, 207 {"2.02226624871116645580e-21", "3BA3198A2E000000"}, 208 {"8.47842766036889956997e-32", "397B839A252049C1"}, 209 210 211 // fdlibm s_cbrt.c 212 {"+5.42857142857142815906e-01", "3FE15F15F15F15F1"}, 213 {"-7.05306122448979611050e-01", "BFE691DE2532C834"}, 214 {"+1.41428571428571436819e+00", "3FF6A0EA0EA0EA0F"}, 215 {"+1.60714285714285720630e+00", "3FF9B6DB6DB6DB6E"}, 216 {"+3.57142857142857150787e-01", "3FD6DB6DB6DB6DB7"}, 217 }; 218 219 // Compare decimal string -> double -> hex string to 220 // long hex string -> double hex string 221 for (int i = 0; i < testCases2.length; i++) { 222 String result; 223 String expected; 224 if(! (result=Double.toHexString(Double.parseDouble(testCases2[i][0]))). 225 equals( expected=hexLongStringtoHexDoubleString(testCases2[i][1]) )) { 226 failures ++; 227 System.err.println("For floating-point string " + testCases2[i][0] + 228 ", expected hex output " + expected + ", got " + result +"."); 229 } 230 } 231 232 // Test random double values; 233 // compare double -> Double.toHexString with local doubleToHexString 234 java.util.Random rand = new java.util.Random(0); 235 for (int i = 0; i < 1000; i++) { 236 String result; 237 String expected; 238 double d = rand.nextDouble(); 239 if(! (expected=doubleToHexString(d)).equals(result=Double.toHexString(d)) ) { 240 failures ++; 241 System.err.println("For floating-point value " + d + 242 ", expected hex output " + expected + ", got " + result +"."); 243 } 244 } 245 246 return failures; 247 } 248 main(String argv[])249 public static void main(String argv[]) { 250 int failures = 0; 251 252 failures = toHexStringTests(); 253 254 if (failures != 0) { 255 throw new RuntimeException("" + failures + " failures while testing Double.toHexString"); 256 } 257 } 258 } 259