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