FloatTest.java revision 2ad60cfc28e14ee8f0bb038720836a4696c478ad
1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package org.apache.harmony.luni.tests.java.lang;
18
19import junit.framework.TestCase;
20
21public class FloatTest extends TestCase {
22
23    private static final int rawBitsFor3_4eN38To38[] = { 0x1394470, 0x2e7958c, 0x490bd77, 0x634ecd5,
24            0x7e2280b, 0x98d5907, 0xb30af48, 0xcdcdb1a, 0xe8a08f0, 0x102c8b2d, 0x11d7adf8,
25            0x1386ccbb, 0x15287fe9, 0x16d29fe4, 0x1883a3ee, 0x1a248cea, 0x1bcdb025, 0x1d808e17,
26            0x1f20b19d, 0x20c8de04, 0x227b1585, 0x241ced73, 0x25c428d0, 0x27753303, 0x29193fe2,
27            0x2abf8fdb, 0x2c6f73d1, 0x2e15a863, 0x2fbb127c, 0x3169d71a, 0x33122671, 0x34b6b00d,
28            0x36645c10, 0x380eb98a, 0x39b267ec, 0x3b5f01e8, 0x3d0b6131, 0x3eae397d, 0x4059c7dc,
29            0x42081cea, 0x43aa2424, 0x4554ad2d, 0x4704ec3c, 0x48a6274b, 0x4a4fb11e, 0x4c01ceb3,
30            0x4da2425f, 0x4f4ad2f7, 0x50fd87b5, 0x529e74d1, 0x54461205, 0x55f79687, 0x579abe14,
31            0x59416d99, 0x5af1c900, 0x5c971da0, 0x5e3ce508, 0x5fec1e4a, 0x619392ee, 0x633877a9,
32            0x64e69594, 0x66901d7c, 0x683424dc, 0x69e12e12, 0x6b8cbccb, 0x6d2febfe, 0x6edbe6fe,
33            0x7089705f, 0x722bcc76, 0x73d6bf94, 0x758637bc, 0x7727c5ac, 0x78d1b717, 0x7a83126e,
34            0x7c23d70a, 0x7dcccccc, 0x7f7fffff };
35
36    private static final String expectedStringFor3_4eN38To38[] = { "3.4028235E-38", "3.4028235E-37",
37            "3.4028233E-36", "3.4028234E-35", "3.4028236E-34", "3.4028236E-33",
38            "3.4028234E-32", "3.4028234E-31", "3.4028233E-30", "3.4028236E-29",
39            "3.4028235E-28", "3.4028235E-27", "3.4028233E-26", "3.4028235E-25",
40            "3.4028233E-24", "3.4028235E-23", "3.4028236E-22", "3.4028235E-21",
41            "3.4028236E-20", "3.4028236E-19", "3.4028236E-18", "3.4028235E-17",
42            "3.4028236E-16", "3.4028234E-15", "3.4028234E-14", "3.4028235E-13",
43            "3.4028234E-12", "3.4028235E-11", "3.4028236E-10", "3.4028234E-9", "3.4028236E-8",
44            "3.4028236E-7", "3.4028235E-6", "3.4028235E-5", "3.4028233E-4", "0.0034028236",
45            "0.034028236", "0.34028235", "3.4028234", "34.028236", "340.28235", "3402.8235",
46            "34028.234", "340282.34", "3402823.5", "3.4028236E7", "3.40282336E8",
47            "3.40282342E9", "3.40282348E10", "3.40282343E11", "3.40282337E12", "3.40282353E13",
48            "3.4028234E14", "3.4028234E15", "3.40282356E16", "3.40282356E17", "3.40282356E18",
49            "3.4028236E19", "3.4028235E20", "3.4028233E21", "3.4028235E22", "3.4028233E23",
50            "3.4028236E24", "3.4028234E25", "3.4028233E26", "3.4028234E27", "3.4028235E28",
51            "3.4028236E29", "3.4028233E30", "3.4028235E31", "3.4028233E32", "3.4028236E33",
52            "3.4028236E34", "3.4028234E35", "3.4028236E36", "3.4028235E37", "3.4028235E38" };
53
54    private static final int rawBitsFor1_17eN38To38[] = { 0x80800000, 0x82200000, 0x83c80000,
55            0x857a0000, 0x871c4000, 0x88c35000, 0x8a742400, 0x8c189680, 0x8dbebc20, 0x8f6e6b28,
56            0x911502f9, 0x92ba43b7, 0x9468d4a5, 0x961184e7, 0x97b5e621, 0x99635fa9, 0x9b0e1bca,
57            0x9cb1a2bc, 0x9e5e0b6b, 0xa00ac723, 0xa1ad78ec, 0xa358d727, 0xa5078678, 0xa6a96816,
58            0xa853c21c, 0xaa045951, 0xaba56fa6, 0xad4ecb8f, 0xaf013f39, 0xb0a18f08, 0xb249f2ca,
59            0xb3fc6f7c, 0xb59dc5ae, 0xb7453719, 0xb8f684df, 0xba9a130c, 0xbc4097ce, 0xbdf0bdc2,
60            0xbf967699, 0xc13c1440, 0xc2eb1950, 0xc492efd2, 0xc637abc6, 0xc7e596b8, 0xc98f7e33,
61            0xcb335dc0, 0xcce0352f, 0xce8c213e, 0xd02f298d, 0xd1daf3f0, 0xd388d876, 0xd52b0e94,
62            0xd6d5d239, 0xd885a363, 0xda270c3c, 0xdbd0cf4b, 0xdd82818f, 0xdf2321f3, 0xe0cbea70,
63            0xe27ee50b, 0xe41f4f27, 0xe5c722f1, 0xe778ebad, 0xe91b934c, 0xeac2781f, 0xec731627,
64            0xee17edd8, 0xefbde94f, 0xf16d63a2, 0xf3145e45, 0xf4b975d7, 0xf667d34c, 0xf810e410,
65            0xf9b51d14, 0xfb626459, 0xfd0d7eb7, 0xfeb0de65 };
66
67    private static final String expectedStringFor1_17eN38To38[] = { "-1.17549435E-38",
68            "-1.1754944E-37", "-1.17549435E-36", "-1.17549435E-35", "-1.1754944E-34",
69            "-1.17549435E-33", "-1.17549435E-32", "-1.1754944E-31", "-1.17549435E-30",
70            "-1.17549435E-29", "-1.1754944E-28", "-1.1754943E-27", "-1.17549435E-26",
71            "-1.1754943E-25", "-1.1754944E-24", "-1.1754943E-23", "-1.1754944E-22",
72            "-1.1754943E-21", "-1.1754943E-20", "-1.1754943E-19", "-1.1754944E-18",
73            "-1.1754944E-17", "-1.1754943E-16", "-1.1754943E-15", "-1.1754944E-14",
74            "-1.1754943E-13", "-1.1754944E-12", "-1.1754943E-11", "-1.1754943E-10",
75            "-1.1754944E-9", "-1.1754944E-8", "-1.1754943E-7", "-1.1754944E-6",
76            "-1.1754943E-5", "-1.1754943E-4", "-0.0011754944", "-0.011754943", "-0.117549434",
77            "-1.1754943", "-11.754944", "-117.54944", "-1175.4944", "-11754.943", "-117549.44",
78            "-1175494.4", "-1.1754944E7", "-1.17549432E8", "-1.1754944E9", "-1.17549435E10",
79            "-1.17549433E11", "-1.17549433E12", "-1.17549438E13", "-1.17549438E14",
80            "-1.1754943E15", "-1.17549432E16", "-1.17549432E17", "-1.17549434E18",
81            "-1.1754944E19", "-1.1754944E20", "-1.1754943E21", "-1.1754943E22",
82            "-1.1754944E23", "-1.17549434E24", "-1.1754943E25", "-1.1754943E26",
83            "-1.17549434E27", "-1.1754943E28", "-1.1754944E29", "-1.1754943E30",
84            "-1.1754943E31", "-1.1754944E32", "-1.1754943E33", "-1.1754944E34",
85            "-1.1754944E35", "-1.1754944E36", "-1.1754943E37", "-1.1754943E38" };
86
87    private void doTestCompareRawBits(String originalFloatString, int expectedRawBits,
88            String expectedString) {
89        int rawBits;
90        float result = Float.parseFloat(originalFloatString);
91        rawBits = Float.floatToIntBits(result);
92        assertEquals("Original float(" + originalFloatString + ") Converted float(" + result
93                + ") Expecting:" + Integer.toHexString(expectedRawBits) + " Got: "
94                + Integer.toHexString(rawBits), expectedRawBits, rawBits);
95    }
96
97    /**
98     * @tests java.lang.Float#Float(float)
99     */
100    public void test_ConstructorF() {
101        // Test for method java.lang.Float(float)
102
103        Float f = new Float(900.89f);
104        assertTrue("Created incorrect float", f.floatValue() == 900.89f);
105    }
106
107    /**
108     * @tests java.lang.Float#Float(java.lang.String)
109     */
110    public void test_ConstructorLjava_lang_String() {
111        // Test for method java.lang.Float(java.lang.String)
112
113        Float f = new Float("900.89");
114        assertTrue("Created incorrect Float", f.floatValue() == 900.89f);
115    }
116
117    /**
118     * @tests java.lang.Float#byteValue()
119     */
120    public void test_byteValue() {
121        // Test for method byte java.lang.Float.byteValue()
122        Float f = new Float(0.46874f);
123        Float f2 = new Float(90.8f);
124        assertTrue("Returned incorrect byte value", f.byteValue() == 0 && f2.byteValue() == 90);
125    }
126
127    /**
128     * @tests java.lang.Float#compareTo(java.lang.Float)
129     * @tests java.lang.Float#compare(float, float)
130     */
131    public void test_compare() {
132        float[] values = new float[] { Float.NEGATIVE_INFINITY, -Float.MAX_VALUE, -2f,
133                -Float.MIN_VALUE, -0f, 0f, Float.MIN_VALUE, 2f, Float.MAX_VALUE,
134                Float.POSITIVE_INFINITY, Float.NaN };
135        for (int i = 0; i < values.length; i++) {
136            float f1 = values[i];
137            assertTrue("compare() should be equal: " + f1, Float.compare(f1, f1) == 0);
138            Float F1 = new Float(f1);
139            assertTrue("compareTo() should be equal: " + f1, F1.compareTo(F1) == 0);
140            for (int j = i + 1; j < values.length; j++) {
141                float f2 = values[j];
142                assertTrue("compare() " + f1 + " should be less " + f2,
143                        Float.compare(f1, f2) == -1);
144                assertTrue("compare() " + f2 + " should be greater " + f1, Float
145                        .compare(f2, f1) == 1);
146                Float F2 = new Float(f2);
147                assertTrue("compareTo() " + f1 + " should be less " + f2,
148                        F1.compareTo(F2) == -1);
149                assertTrue("compareTo() " + f2 + " should be greater " + f1,
150                        F2.compareTo(F1) == 1);
151            }
152        }
153
154        try {
155            new Float(0.0F).compareTo(null);
156            fail("No NPE");
157        } catch (NullPointerException e) {
158        }
159    }
160
161    /**
162     * @tests java.lang.Float#doubleValue()
163     */
164    public void test_doubleValue() {
165        // Test for method double java.lang.Float.doubleValue()
166        assertTrue("Incorrect double value returned", Math.abs(new Float(999999.999f)
167                .doubleValue() - 999999.999d) < 1);
168    }
169
170    /**
171     * @tests java.lang.Float#floatToIntBits(float)
172     */
173    public void test_floatToIntBitsF() {
174        float f = 9876.2345f;
175        int bits = Float.floatToIntBits(f);
176        float r = Float.intBitsToFloat(bits);
177        assertTrue("Incorrect intBits returned", f == r);
178    }
179
180    /**
181     * @tests java.lang.Float#floatToRawIntBits(float)
182     */
183    public void test_floatToRawIntBitsF() {
184        int i = 0x7fc004d2;
185        float f = Float.intBitsToFloat(i);
186        assertTrue("Wrong raw bits", Float.floatToRawIntBits(f) == i);
187    }
188
189    /**
190     * @tests java.lang.Float#floatValue()
191     */
192    public void test_floatValue() {
193        // Test for method float java.lang.Float.floatValue()
194        Float f = new Float(87.657f);
195        Float f2 = new Float(-0.876f);
196        assertTrue("Returned incorrect floatValue", f.floatValue() == 87.657f
197                && (f2.floatValue() == -0.876f));
198
199    }
200
201    /**
202     * @tests java.lang.Float#hashCode()
203     */
204    public void test_hashCode() {
205        // Test for method int java.lang.Float.hashCode()
206        Float f = new Float(1908.8786f);
207        assertTrue("Returned invalid hash code for 1908.8786f", f.hashCode() == Float
208                .floatToIntBits(1908.8786f));
209
210        f = new Float(-1.112f);
211        assertTrue("Returned invalid hash code for -1.112", f.hashCode() == Float
212                .floatToIntBits(-1.112f));
213
214        f = new Float(0f);
215        assertTrue("Returned invalid hash code for 0", f.hashCode() == Float.floatToIntBits(0f));
216
217    }
218
219    /**
220     * @tests java.lang.Float#intBitsToFloat(int)
221     */
222    public void test_intBitsToFloatI() {
223        float f = 9876.2345f;
224        int bits = Float.floatToIntBits(f);
225        float r = Float.intBitsToFloat(bits);
226        assertEquals("Incorrect intBits returned", f, r, 0F);
227    }
228
229    /**
230     * @tests java.lang.Float#intValue()
231     */
232    public void test_intValue() {
233        // Test for method int java.lang.Float.intValue()
234        Float f = new Float(0.46874f);
235        Float f2 = new Float(90.8f);
236        assertTrue("Returned incorrect int value", f.intValue() == 0 && f2.intValue() == 90);
237    }
238
239    /**
240     * @tests java.lang.Float#isInfinite()
241     */
242    public void test_isInfinite() {
243        // Test for method boolean java.lang.Float.isInfinite()
244        assertTrue("Infinity check failed",
245                (new Float(Float.POSITIVE_INFINITY).isInfinite() && new Float(
246                        Float.NEGATIVE_INFINITY).isInfinite())
247                        && !(new Float(0.13131414f).isInfinite()));
248    }
249
250    /**
251     * @tests java.lang.Float#isInfinite(float)
252     */
253    public void test_isInfiniteF() {
254        // Test for method boolean java.lang.Float.isInfinite(float)
255
256        assertTrue("Infinity check failed", Float.isInfinite(Float.POSITIVE_INFINITY)
257                && (Float.isInfinite(Float.NEGATIVE_INFINITY)) && !(Float.isInfinite(1.0f)));
258    }
259
260    /**
261     * @tests java.lang.Float#isNaN()
262     */
263    public void test_isNaN() {
264        // Test for method boolean java.lang.Float.isNaN()
265        assertTrue("NAN check failed", new Float(Float.NaN).isNaN()
266                && !(new Float(1.0f).isNaN()));
267    }
268
269    /**
270     * @tests java.lang.Float#isNaN(float)
271     */
272    public void test_isNaNF() {
273        // Test for method boolean java.lang.Float.isNaN(float)
274        assertTrue("NaN check failed", Float.isNaN(Float.NaN) && !(Float.isNaN(12.09f)));
275    }
276
277    /**
278     * @tests java.lang.Float#longValue()
279     */
280    public void test_longValue() {
281        // Test for method long java.lang.Float.longValue()
282        Float f = new Float(0.46874f);
283        Float f2 = new Float(90.8f);
284        assertTrue("Returned incorrect long value", f.longValue() == 0 && f2.longValue() == 90);
285    }
286
287    /**
288     * @tests java.lang.Float#parseFloat(java.lang.String)
289     */
290    public void test_parseFloatLjava_lang_String() {
291        assertEquals("Incorrect float returned, expected zero.", 0.0, Float
292                .parseFloat("7.0064923216240853546186479164495e-46"), 0.0);
293        assertEquals("Incorrect float returned, expected minimum float.", Float.MIN_VALUE,
294                Float.parseFloat("7.0064923216240853546186479164496e-46"), 0.0);
295
296        doTestCompareRawBits(
297                "0.000000000000000000000000000000000000011754942807573642917278829910357665133228589927589904276829631184250030649651730385585324256680905818939208984375",
298                0x800000, "1.17549435E-38");
299        doTestCompareRawBits(
300                "0.00000000000000000000000000000000000001175494280757364291727882991035766513322858992758990427682963118425003064965173038558532425668090581893920898437499999f",
301                0x7fffff, "1.1754942E-38");
302
303        /* Test a set of regular floats with exponents from -38 to +38 */
304        for (int i = 38; i > 3; i--) {
305            String testString;
306            testString = "3.4028234663852886e-" + i;
307            doTestCompareRawBits(testString, rawBitsFor3_4eN38To38[38 - i],
308                    expectedStringFor3_4eN38To38[38 - i]);
309        }
310        doTestCompareRawBits("3.4028234663852886e-3", rawBitsFor3_4eN38To38[38 - 3],
311                expectedStringFor3_4eN38To38[38 - 3]);
312        doTestCompareRawBits("3.4028234663852886e-2", rawBitsFor3_4eN38To38[38 - 2],
313                expectedStringFor3_4eN38To38[38 - 2]);
314        doTestCompareRawBits("3.4028234663852886e-1", rawBitsFor3_4eN38To38[38 - 1],
315                expectedStringFor3_4eN38To38[38 - 1]);
316        doTestCompareRawBits("3.4028234663852886e-0", rawBitsFor3_4eN38To38[38 - 0],
317                expectedStringFor3_4eN38To38[38 - 0]);
318        doTestCompareRawBits("3.4028234663852886e+1", rawBitsFor3_4eN38To38[38 + 1],
319                expectedStringFor3_4eN38To38[38 + 1]);
320        doTestCompareRawBits("3.4028234663852886e+2", rawBitsFor3_4eN38To38[38 + 2],
321                expectedStringFor3_4eN38To38[38 + 2]);
322        doTestCompareRawBits("3.4028234663852886e+3", rawBitsFor3_4eN38To38[38 + 3],
323                expectedStringFor3_4eN38To38[38 + 3]);
324        doTestCompareRawBits("3.4028234663852886e+4", rawBitsFor3_4eN38To38[38 + 4],
325                expectedStringFor3_4eN38To38[38 + 4]);
326        doTestCompareRawBits("3.4028234663852886e+5", rawBitsFor3_4eN38To38[38 + 5],
327                expectedStringFor3_4eN38To38[38 + 5]);
328        doTestCompareRawBits("3.4028234663852886e+6", rawBitsFor3_4eN38To38[38 + 6],
329                expectedStringFor3_4eN38To38[38 + 6]);
330
331        for (int i = 7; i < 39; i++) {
332            String testString;
333            testString = "3.4028234663852886e+" + i;
334            doTestCompareRawBits(testString, rawBitsFor3_4eN38To38[38 + i],
335                    expectedStringFor3_4eN38To38[38 + i]);
336        }
337
338        /* Test another set of regular floats with exponents from -38 to +38 */
339        for (int i = 38; i > 3; i--) {
340            String testString;
341            testString = "-1.1754943508222875e-" + i;
342            doTestCompareRawBits(testString, rawBitsFor1_17eN38To38[38 - i],
343                    expectedStringFor1_17eN38To38[38 - i]);
344        }
345        doTestCompareRawBits("-1.1754943508222875e-3", rawBitsFor1_17eN38To38[38 - 3],
346                expectedStringFor1_17eN38To38[38 - 3]);
347        doTestCompareRawBits("-1.1754943508222875e-2", rawBitsFor1_17eN38To38[38 - 2],
348                expectedStringFor1_17eN38To38[38 - 2]);
349        doTestCompareRawBits("-1.1754943508222875e-1", rawBitsFor1_17eN38To38[38 - 1],
350                expectedStringFor1_17eN38To38[38 - 1]);
351        doTestCompareRawBits("-1.1754943508222875e-0", rawBitsFor1_17eN38To38[38 - 0],
352                expectedStringFor1_17eN38To38[38 - 0]);
353        doTestCompareRawBits("-1.1754943508222875e+1", rawBitsFor1_17eN38To38[38 + 1],
354                expectedStringFor1_17eN38To38[38 + 1]);
355        doTestCompareRawBits("-1.1754943508222875e+2", rawBitsFor1_17eN38To38[38 + 2],
356                expectedStringFor1_17eN38To38[38 + 2]);
357        doTestCompareRawBits("-1.1754943508222875e+3", rawBitsFor1_17eN38To38[38 + 3],
358                expectedStringFor1_17eN38To38[38 + 3]);
359        doTestCompareRawBits("-1.1754943508222875e+4", rawBitsFor1_17eN38To38[38 + 4],
360                expectedStringFor1_17eN38To38[38 + 4]);
361        doTestCompareRawBits("-1.1754943508222875e+5", rawBitsFor1_17eN38To38[38 + 5],
362                expectedStringFor1_17eN38To38[38 + 5]);
363        doTestCompareRawBits("-1.1754943508222875e+6", rawBitsFor1_17eN38To38[38 + 6],
364                expectedStringFor1_17eN38To38[38 + 6]);
365
366        for (int i = 7; i < 39; i++) {
367            String testString;
368            testString = "-1.1754943508222875e+" + i;
369            doTestCompareRawBits(testString, rawBitsFor1_17eN38To38[38 + i],
370                    expectedStringFor1_17eN38To38[38 + i]);
371        }
372
373        /* Test denormalized floats (floats with exponents <= -38 */
374        doTestCompareRawBits("1.1012984643248170E-45", 1, "1.4E-45");
375        doTestCompareRawBits("-1.1012984643248170E-45", 0x80000001, "-1.4E-45");
376        doTestCompareRawBits("1.0E-45", 1, "1.4E-45");
377        doTestCompareRawBits("-1.0E-45", 0x80000001, "-1.4E-45");
378        doTestCompareRawBits("0.9E-45", 1, "1.4E-45");
379        doTestCompareRawBits("-0.9E-45", 0x80000001, "-1.4E-45");
380        doTestCompareRawBits("4.203895392974451e-45", 3, "4.2E-45");
381        doTestCompareRawBits("-4.203895392974451e-45", 0x80000003, "-4.2E-45");
382        doTestCompareRawBits("0.004E-45", 0, "0.0");
383        doTestCompareRawBits("-0.004E-45", 0x80000000, "-0.0");
384
385        /*
386         * Test for large floats close to and greater than 3.4028235E38 and
387         * -3.4028235E38
388         */
389        doTestCompareRawBits("1.2E+38", 0x7eb48e52, "1.2E38");
390        doTestCompareRawBits("-1.2E+38", 0xfeb48e52, "-1.2E38");
391        doTestCompareRawBits("3.2E+38", 0x7f70bdc2, "3.2E38");
392        doTestCompareRawBits("-3.2E+38", 0xff70bdc2, "-3.2E38");
393        doTestCompareRawBits("3.4E+38", 0x7f7fc99e, "3.4E38");
394        doTestCompareRawBits("-3.4E+38", 0xff7fc99e, "-3.4E38");
395        doTestCompareRawBits("3.4028234663852886E+38", 0x7f7fffff, "3.4028235E38");
396        doTestCompareRawBits("-3.4028234663852886E+38", 0xff7fffff, "-3.4028235E38");
397        doTestCompareRawBits("3.405E+38", 0x7f800000, "Infinity");
398        doTestCompareRawBits("-3.405E+38", 0xff800000, "-Infinity");
399        doTestCompareRawBits("3.41E+38", 0x7f800000, "Infinity");
400        doTestCompareRawBits("-3.41E+38", 0xff800000, "-Infinity");
401        doTestCompareRawBits("3.42E+38", 0x7f800000, "Infinity");
402        doTestCompareRawBits("-3.42E+38", 0xff800000, "-Infinity");
403        doTestCompareRawBits("1.0E+39", 0x7f800000, "Infinity");
404        doTestCompareRawBits("-1.0E+39", 0xff800000, "-Infinity");
405    }
406
407    /**
408     * @tests java.lang.Float#parseFloat(java.lang.String)
409     */
410    public void test_parseFloat_LString_Unusual() {
411        float actual;
412
413        actual = Float.parseFloat("0x00000000000000000000000000000000000000000.0000000000000000000000000000000000000p0000000000000000000000000000000000");
414        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
415
416        actual = Float.parseFloat("+0Xfffff.fffffffffffffffffffffffffffffffp+99F");
417        assertEquals("Returned incorrect value", 6.64614E35f, actual, 0.0F);
418
419        actual = Float.parseFloat("-0X.123456789abcdefp+99f");
420        assertEquals("Returned incorrect value", -4.5072022E28f, actual, 0.0F);
421
422        actual = Float.parseFloat("-0X123456789abcdef.p+1f");
423        assertEquals("Returned incorrect value", -1.63971062E17f, actual, 0.0F);
424
425        actual = Float.parseFloat("-0X000000000000000000000000000001abcdef.0000000000000000000000000001abefp00000000000000000000000000000000000000000004f");
426        assertEquals("Returned incorrect value", -4.48585472E8f, actual, 0.0F);
427
428        actual = Float.parseFloat("0X0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234p600f");
429        assertEquals("Returned incorrect value", 5.907252E33f, actual, 0.0F);
430
431        actual = Float.parseFloat("0x1.p9223372036854775807");
432        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
433
434        actual = Float.parseFloat("0x1.p9223372036854775808");
435        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
436
437        actual = Float.parseFloat("0x10.p9223372036854775808");
438        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
439
440        actual = Float.parseFloat("0xabcd.ffffffffp+2000");
441        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
442
443        actual = Float.parseFloat("0x1.p-9223372036854775808");
444        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
445
446        actual = Float.parseFloat("0x1.p-9223372036854775809");
447        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
448
449        actual = Float.parseFloat("0x.1p-9223372036854775809");
450        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
451    }
452
453    /**
454     * @tests java.lang.Float#parseFloat(java.lang.String)
455     */
456    public void test_parseFloat_LString_NormalPositiveExponent() {
457        int[] expecteds = {
458                0x3991a2b4,                0x43cc0247,                0x47909009,
459                0x4ac0c009,                0x4e109005,                0x5140c005,
460                0x5458d805,                0x57848402,                0x5a909002,
461                0x5da8a802,                0x60c0c002,                0x63cccc02,
462                0x66e4e402,                0x69f0f002,                0x6d048401,
463                0x70109001,                0x73169601,                0x76810810,
464                0x79840840,                0x7c8a08a0,                0x7f800000,
465                0x7f800000,                0x7f800000,                0x7f800000,
466                0x7f800000,
467        };
468
469        for (int i = 0; i < expecteds.length; i++) {
470            int part = i * 6;
471            String inputString = "0x" + part + "." + part + "0123456789abcdefp" + part;
472
473            float actual = Float.parseFloat(inputString);
474            float expected = Float.intBitsToFloat(expecteds[i]);
475
476            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
477            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
478            String errorMsg = i + "th input string is:<" + inputString
479            + ">.The expected result should be:<" + expectedString
480            + ">, but was: <" + actualString + ">. ";
481
482            assertEquals(errorMsg, expected, actual, 0.0F);
483        }
484    }
485
486    /**
487     * @tests java.lang.Float#parseFloat(java.lang.String)
488     */
489    public void test_parseFloat_LString_NormalNegativeExponent() {
490        int[] expecteds = {
491                0x3991a2b4,
492                0x3d6e0247,
493                0x3aa0a009,
494                0x37848405,
495                0x3420a005,
496                0x30d4d405,
497                0x2d848402,
498                0x2a129202,
499                0x26acac02,
500                0x2346c602,
501                0x1fe0e002,
502                0x1c6eee02,
503                0x19048401,
504                0x15919101,
505                0x12189801,
506                0xf028828,
507                0xb890890,
508                0x80c88c8,
509                0x4930930,
510                0x1198998,
511                0x28028,
512                0x51c,
513                0xb,
514                0x0,
515                0x0,
516        };
517
518        for (int i = 0; i < expecteds.length; i++) {
519            int part = i * 7;
520            String inputString = "0x" + part + "." + part + "0123456789abcdefp-"  + part;
521
522            float actual = Float.parseFloat(inputString);
523            float expected = Float.intBitsToFloat(expecteds[i]);
524
525            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
526            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
527            String errorMsg = i + "th input string is:<" + inputString
528            + ">.The expected result should be:<" + expectedString
529            + ">, but was: <" + actualString + ">. ";
530
531            assertEquals(errorMsg, expected, actual, 0.0F);
532        }
533    }
534
535    /**
536     * @tests java.lang.Float#parseFloat(java.lang.String)
537     */
538    public void test_parseFloat_LString_MaxNormalBoundary() {
539        int[] expecteds ={
540                0x7f7fffff,
541                0x7f7fffff,
542                0x7f7fffff,
543                0x7f800000,
544                0x7f800000,
545                0x7f800000,
546
547                0xff7fffff,
548                0xff7fffff,
549                0xff7fffff,
550                0xff800000,
551                0xff800000,
552                0xff800000,
553        };
554
555        String[] inputs = {
556                "0x1.fffffep127",
557                "0x1.fffffe000000000000000000000000000000000000000000000001p127",
558                "0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
559                "0x1.ffffffp127",
560                "0x1.ffffff000000000000000000000000000000000000000000000001p127",
561                "0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
562
563                "-0x1.fffffep127",
564                "-0x1.fffffe000000000000000000000000000000000000000000000001p127",
565                "-0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
566                "-0x1.ffffffp127",
567                "-0x1.ffffff000000000000000000000000000000000000000000000001p127",
568                "-0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
569        };
570
571        for (int i = 0; i < inputs.length; i++) {
572            float actual = Float.parseFloat(inputs[i]);
573            float expected = Float.intBitsToFloat(expecteds[i]);
574
575            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
576            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
577            String errorMsg = i + "th input string is:<" + inputs[i]
578            + ">.The expected result should be:<" + expectedString
579            + ">, but was: <" + actualString + ">. ";
580
581            assertEquals(errorMsg, expected, actual, 0.0F);
582        }
583    }
584
585    /**
586     * @tests java.lang.Float#parseFloat(java.lang.String)
587     */
588    public void test_parseFloat_LString_MinNormalBoundary() {
589        int expecteds[] = {
590                0x800000,
591                0x800000,
592                0x800000,
593                0x800000,
594                0x800001,
595                0x800001,
596
597                0x80800000,
598                0x80800000,
599                0x80800000,
600                0x80800000,
601                0x80800001,
602                0x80800001,
603        };
604
605        String inputs[] = {
606                "0x1.0p-126",
607                "0x1.00000000000000000000000000000000000000000000001p-126",
608                "0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
609                "0x1.000001p-126",
610                "0x1.000001000000000000000000000000000000000000000001p-126",
611                "0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
612
613                "-0x1.0p-126",
614                "-0x1.00000000000000000000000000000000000000000000001p-126",
615                "-0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
616                "-0x1.000001p-126",
617                "-0x1.000001000000000000000000000000000000000000000001p-126",
618                "-0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
619        };
620
621        for (int i = 0; i < inputs.length; i++) {
622            float actual = Float.parseFloat(inputs[i]);
623            float expected = Float.intBitsToFloat(expecteds[i]);
624
625            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
626            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
627            String errorMsg = i + "th input string is:<" + inputs[i]
628            + ">.The expected result should be:<" + expectedString
629            + ">, but was: <" + actualString + ">. ";
630
631            assertEquals(errorMsg, expected, actual, 0.0F);
632        }
633    }
634
635    /**
636     * @tests java.lang.Float#parseFloat(java.lang.String)
637     */
638    public void test_parseFloat_LString_MaxSubNormalBoundary() {
639        int expecteds[] = {
640                0x7fffff,
641                0x7fffff,
642                0x7fffff,
643                0x800000,
644                0x800000,
645                0x800000,
646
647                0x807fffff,
648                0x807fffff,
649                0x807fffff,
650                0x80800000,
651                0x80800000,
652                0x80800000,
653        };
654
655        String inputs[] = {
656                "0x0.fffffep-126",
657                "0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
658                "0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
659                "0x0.ffffffp-126",
660                "0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
661                "0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
662
663                "-0x0.fffffep-126",
664                "-0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
665                "-0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
666                "-0x0.ffffffp-126",
667                "-0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
668                "-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
669        };
670
671        for (int i = 0; i < inputs.length; i++) {
672            float actual = Float.parseFloat(inputs[i]);
673            float expected = Float.intBitsToFloat(expecteds[i]);
674
675            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
676            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
677            String errorMsg = i + "th input string is:<" + inputs[i]
678            + ">.The expected result should be:<" + expectedString
679            + ">, but was: <" + actualString + ">. ";
680
681            assertEquals(errorMsg, expected, actual, 0.0F);
682        }
683    }
684
685    /**
686     * @tests java.lang.Float#parseFloat(java.lang.String)
687     */
688    public void test_parseFloat_LString_MinSubNormalBoundary() {
689        int expecteds[] = {
690                0x1,
691                0x1,
692                0x1,
693                0x2,
694                0x2,
695                0x2,
696
697                0x80000001,
698                0x80000001,
699                0x80000001,
700                0x80000002,
701                0x80000002,
702                0x80000002,
703        };
704
705        String inputs[] = {
706                "0x0.000002p-126",
707                "0x0.00000200000000000000000000000000000000000001p-126",
708                "0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
709                "0x0.000003p-126",
710                "0x0.000003000000000000000000000000000000000000001p-126",
711                "0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
712
713                "-0x0.000002p-126",
714                "-0x0.00000200000000000000000000000000000000000001p-126",
715                "-0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
716                "-0x0.000003p-126",
717                "-0x0.000003000000000000000000000000000000000000001p-126",
718                "-0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
719        };
720
721        for (int i = 0; i < inputs.length; i++) {
722            float actual = Float.parseFloat(inputs[i]);
723            float expected = Float.intBitsToFloat(expecteds[i]);
724
725            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
726            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
727            String errorMsg = i + "th input string is:<" + inputs[i]
728            + ">.The expected result should be:<" + expectedString
729            + ">, but was: <" + actualString + ">. ";
730
731            assertEquals(errorMsg, expected, actual, 0.0F);
732        }
733    }
734
735    /**
736     * @tests java.lang.Float#parseFloat(java.lang.String)
737     */
738    public void test_parseFloat_LString_ZeroBoundary() {
739        int expecteds[] = {
740                0x0,
741                0x0,
742                0x0,
743                0x0,
744                0x1,
745                0x1,
746
747                0x80000000,
748                0x80000000,
749                0x80000000,
750                0x80000000,
751                0x80000001,
752                0x80000001,
753        };
754
755        String inputs[] = {
756                "0x0.000000000000000p-126",
757                "0x0.000000000000000000000000000000000000000000000001p-126",
758                "0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
759                "0x0.000001p-126",
760                "0x0.000001000000000000000000000000000000000000000001p-126",
761                "0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
762
763                "-0x0.000000000000000p-126",
764                "-0x0.000000000000000000000000000000000000000000000001p-126",
765                "-0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
766                "-0x0.000001p-126",
767                "-0x0.000001000000000000000000000000000000000000000001p-126",
768                "-0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
769        };
770
771        for (int i = 0; i < inputs.length; i++) {
772            float actual = Float.parseFloat(inputs[i]);
773            float expected = Float.intBitsToFloat(expecteds[i]);
774
775            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
776            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
777            String errorMsg = i + "th input string is:<" + inputs[i]
778            + ">.The expected result should be:<" + expectedString
779            + ">, but was: <" + actualString + ">. ";
780
781            assertEquals(errorMsg, expected, actual, 0.0F);
782        }
783    }
784
785    /**
786     * @tests java.lang.Float#shortValue()
787     */
788    public void test_shortValue() {
789        // Test for method short java.lang.Float.shortValue()
790        Float f = new Float(0.46874f);
791        Float f2 = new Float(90.8f);
792        assertTrue("Returned incorrect short value", f.shortValue() == 0
793                && f2.shortValue() == 90);
794    }
795
796    /**
797     * @tests java.lang.Float#toString()
798     */
799    public void test_toString() {
800        // Test for method java.lang.String java.lang.Float.toString()
801
802        test_toString(12.90898f, "12.90898");
803
804        test_toString(1.7014118346046924e+38F, "1.7014118E38");
805    }
806
807    /**
808     * @tests java.lang.Float#toString(float)
809     */
810    public void test_toStringF() {
811        // Test for method java.lang.String java.lang.Float.toString(float)
812
813        float ff;
814        String answer;
815
816        ff = 12.90898f;
817        answer = "12.90898";
818        assertTrue("Incorrect String representation want " + answer + ", got "
819                + Float.toString(ff), Float.toString(ff).equals(answer));
820
821        ff = Float.MAX_VALUE;
822        answer = "3.4028235E38";
823        assertTrue("Incorrect String representation want " + answer + ", got "
824                + Float.toString(ff), Float.toString(ff).equals(answer));
825    }
826
827    /**
828     * @tests java.lang.Float#valueOf(java.lang.String)
829     */
830    public void test_valueOfLjava_lang_String() {
831        // Test for method java.lang.Float
832        // java.lang.Float.valueOf(java.lang.String)
833
834        Float wanted = new Float(432.1235f);
835        Float got = Float.valueOf("432.1235");
836        assertTrue("Incorrect float returned--wanted: " + wanted + " but got: " + got, got
837                .equals(wanted));
838
839        wanted = new Float(0f);
840        got = Float.valueOf("0");
841        assertTrue("Incorrect float returned--wanted: " + wanted + " but got: " + got, got
842                .equals(wanted));
843
844        wanted = new Float(-1212.3232f);
845        got = Float.valueOf("-1212.3232");
846        assertTrue("Incorrect float returned--wanted: " + wanted + " but got: " + got, got
847                .equals(wanted));
848
849        try {
850            Float.valueOf(null);
851            fail("Expected Float.valueOf(null) to throw NPE.");
852        } catch (NullPointerException ex) {
853            // expected
854        } catch (Exception ex) {
855            fail("Expected Float.valueOf(null) to throw NPE not " + ex.getClass().getName());
856        }
857
858        try {
859            Float.valueOf("");
860            fail("Expected Float.valueOf(\"\") to throw NFE");
861        } catch (NumberFormatException e) {
862            // expected
863        }
864
865        Float posZero = Float.valueOf("+0.0");
866        Float negZero = Float.valueOf("-0.0");
867        assertFalse("Floattest0", posZero.equals(negZero));
868        assertTrue("Floattest1", 0.0f == -0.0f);
869
870        // Tests for float values by name.
871        Float expectedNaN = new Float(Float.NaN);
872
873        Float posNaN = Float.valueOf("NaN");
874        assertTrue("Floattest2", posNaN.equals(expectedNaN));
875
876        Float posNaNSigned = Float.valueOf("+NaN");
877        assertTrue("Floattest3", posNaNSigned.equals(expectedNaN));
878
879        Float negNaNSigned = Float.valueOf("-NaN");
880        assertTrue("Floattest4", negNaNSigned.equals(expectedNaN));
881
882        Float posInfinite = Float.valueOf("Infinity");
883        assertTrue("Floattest5", posInfinite.equals(new Float(Float.POSITIVE_INFINITY)));
884
885        Float posInfiniteSigned = Float.valueOf("+Infinity");
886        assertTrue("Floattest6", posInfiniteSigned.equals(new Float(Float.POSITIVE_INFINITY)));
887
888        Float negInfiniteSigned = Float.valueOf("-Infinity");
889        assertTrue("Floattest7", negInfiniteSigned.equals(new Float(Float.NEGATIVE_INFINITY)));
890    }
891
892    private void test_toString(float ff, String answer) {
893        // Test for method java.lang.String java.lang.Double.toString(double)
894        assertTrue("Incorrect String representation want " + answer + ", got ("
895                + Float.toString(ff) + ")", Float.toString(ff).equals(answer));
896        Float f = new Float(ff);
897        assertTrue("Incorrect String representation want " + answer + ", got ("
898                + Float.toString(f.floatValue()) + ")", Float.toString(f.floatValue()).equals(
899                answer));
900        assertTrue("Incorrect String representation want " + answer + ", got (" + f.toString()
901                + ")", f.toString().equals(answer));
902    }
903
904    /**
905     * @tests java.lang.Float#compareTo(java.lang.Float)
906     * @tests java.lang.Float#compare(float, float)
907     */
908    public void test_compareToLjava_lang_Float() {
909        // A selection of float values in ascending order.
910        float[] values = new float[] { Float.NEGATIVE_INFINITY, -Float.MAX_VALUE, -2f,
911                -Float.MIN_VALUE, -0f, 0f, Float.MIN_VALUE, 2f, Float.MAX_VALUE,
912                Float.POSITIVE_INFINITY, Float.NaN };
913
914        for (int i = 0; i < values.length; i++) {
915            float f1 = values[i];
916
917            // Test that each value compares equal to itself; and each object is
918            // equal to another object
919            // like itself
920            assertTrue("Assert 0: compare() should be equal: " + f1, Float.compare(f1, f1) == 0);
921            Float objFloat = new Float(f1);
922            assertTrue("Assert 1: compareTo() should be equal: " + objFloat, objFloat
923                    .compareTo(objFloat) == 0);
924
925            // Test that the Float-defined order is respected
926            for (int j = i + 1; j < values.length; j++) {
927                float f2 = values[j];
928                assertTrue("Assert 2: compare() " + f1 + " should be less " + f2, Float
929                        .compare(f1, f2) == -1);
930                assertTrue("Assert 3: compare() " + f2 + " should be greater " + f1, Float
931                        .compare(f2, f1) == 1);
932
933                Float F2 = new Float(f2);
934                assertTrue("Assert 4: compareTo() " + f1 + " should be less " + f2, objFloat
935                        .compareTo(F2) == -1);
936                assertTrue("Assert 5: compareTo() " + f2 + " should be greater " + f1, F2
937                        .compareTo(objFloat) == 1);
938            }
939        }
940    }
941
942    /**
943     * @tests java.lang.Float#equals(java.lang.Object)
944     */
945    public void test_equalsLjava_lang_Object() {
946        Float f1 = new Float(8765.4321f);
947        Float f2 = new Float(8765.4321f);
948        Float f3 = new Float(-1.0f);
949        assertTrue("Assert 0: Equality test failed", f1.equals(f2) && !(f1.equals(f3)));
950
951        assertTrue("Assert 1: NaN should not be == Nan", Float.NaN != Float.NaN);
952        assertTrue("Assert 2: NaN should not be == Nan", new Float(Float.NaN).equals(new Float(
953                Float.NaN)));
954        assertTrue("Assert 3: -0f should be == 0f", 0f == -0f);
955        assertTrue("Assert 4: -0f should not be equals() 0f", !new Float(0f).equals(new Float(
956                -0f)));
957
958        f1 = new Float(1098.576f);
959        f2 = new Float(1098.576f);
960        f3 = new Float(1.0f);
961        assertTrue("Equality test failed", f1.equals(f2) && !(f1.equals(f3)));
962
963        assertTrue("NaN should not be == Nan", Float.NaN != Float.NaN);
964        assertTrue("NaN should not be == Nan", new Float(Float.NaN)
965                .equals(new Float(Float.NaN)));
966        assertTrue("-0f should be == 0f", 0f == -0f);
967        assertTrue("-0f should not be equals() 0f", !new Float(0f).equals(new Float(-0f)));
968    }
969
970    /**
971     * @tests java.lang.Float#toHexString(float)
972     */
973    public void test_toHexStringF() {
974        // the follow values comes from the Float Javadoc/Spec
975        assertEquals("0x0.0p0", Float.toHexString(0.0F));
976        assertEquals("-0x0.0p0", Float.toHexString(-0.0F));
977        assertEquals("0x1.0p0", Float.toHexString(1.0F));
978        assertEquals("-0x1.0p0", Float.toHexString(-1.0F));
979        assertEquals("0x1.0p1", Float.toHexString(2.0F));
980        assertEquals("0x1.8p1", Float.toHexString(3.0F));
981        assertEquals("0x1.0p-1", Float.toHexString(0.5F));
982        assertEquals("0x1.0p-2", Float.toHexString(0.25F));
983        assertEquals("0x1.fffffep127", Float.toHexString(Float.MAX_VALUE));
984        assertEquals("0x0.000002p-126", Float.toHexString(Float.MIN_VALUE));
985
986        // test edge cases
987        assertEquals("NaN", Float.toHexString(Float.NaN));
988        assertEquals("-Infinity", Float.toHexString(Float.NEGATIVE_INFINITY));
989        assertEquals("Infinity", Float.toHexString(Float.POSITIVE_INFINITY));
990
991        // test various numbers
992        assertEquals("-0x1.da8p6", Float.toHexString(-118.625F));
993        assertEquals("0x1.295788p23", Float.toHexString(9743299.65F));
994        assertEquals("0x1.295788p23", Float.toHexString(9743299.65000F));
995        assertEquals("0x1.295788p23", Float.toHexString(9743299.650001234F));
996        assertEquals("0x1.700d1p33", Float.toHexString(12349743299.65000F));
997
998        // test HARMONY-2132
999        assertEquals("0x1.01p10", Float.toHexString(0x1.01p10f));
1000    }
1001
1002    /**
1003     * @tests java.lang.Float#valueOf(float)
1004     */
1005    public void test_valueOfF() {
1006        assertEquals(new Float(Float.MIN_VALUE), Float.valueOf(Float.MIN_VALUE));
1007        assertEquals(new Float(Float.MAX_VALUE), Float.valueOf(Float.MAX_VALUE));
1008        assertEquals(new Float(0), Float.valueOf(0));
1009
1010        int s = -128;
1011        while (s < 128) {
1012            assertEquals(new Float(s), Float.valueOf(s));
1013            assertEquals(new Float(s + 0.1F), Float.valueOf(s + 0.1F));
1014            assertEquals(Float.valueOf(s + 0.1F), Float.valueOf(s + 0.1F));
1015            s++;
1016        }
1017    }
1018}
1019