1 //===-- Unittests for strtof ---------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "src/__support/FPUtil/FPBits.h"
10 #include "src/stdlib/strtof.h"
11 
12 #include "utils/UnitTest/Test.h"
13 #include "utils/testutils/RoundingModeUtils.h"
14 
15 #include <errno.h>
16 #include <limits.h>
17 #include <stddef.h>
18 
19 using __llvm_libc::testutils::ForceRoundingModeTest;
20 using __llvm_libc::testutils::RoundingMode;
21 
22 class LlvmLibcStrToFTest : public __llvm_libc::testing::Test,
23                            ForceRoundingModeTest<RoundingMode::Nearest> {
24 public:
25   void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
26                 const uint32_t expectedRawData, const int expectedErrno = 0) {
27     // expectedRawData is the expected float result as a uint32_t, organized
28     // according to IEEE754:
29     //
30     // +-- 1 Sign Bit      +-- 23 Mantissa bits
31     // |                   |
32     // |        +----------+----------+
33     // |        |                     |
34     // SEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMM
35     //  |      |
36     //  +--+---+
37     //     |
38     //     +-- 8 Exponent Bits
39     //
40     //  This is so that the result can be compared in parts.
41     char *str_end = nullptr;
42 
43     __llvm_libc::fputil::FPBits<float> expected_fp =
44         __llvm_libc::fputil::FPBits<float>(expectedRawData);
45 
46     errno = 0;
47     float result = __llvm_libc::strtof(inputString, &str_end);
48 
49     __llvm_libc::fputil::FPBits<float> actual_fp =
50         __llvm_libc::fputil::FPBits<float>(result);
51 
52     EXPECT_EQ(str_end - inputString, expectedStrLen);
53 
54     EXPECT_EQ(actual_fp.bits, expected_fp.bits);
55     EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
56     EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
57     EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
58     EXPECT_EQ(errno, expectedErrno);
59   }
60 };
61 
62 // This is the set of tests that I have working (verified correct when compared
63 // to system libc). This is here so I don't break more things when I try to fix
64 // them.
65 
66 TEST_F(LlvmLibcStrToFTest, BasicDecimalTests) {
67   run_test("1", 1, 0x3f800000);
68   run_test("123", 3, 0x42f60000);
69   run_test("1234567890", 10, 0x4e932c06u);
70   run_test("123456789012345678901", 21, 0x60d629d4);
71   run_test("0.1", 3, 0x3dcccccdu);
72   run_test(".1", 2, 0x3dcccccdu);
73   run_test("-0.123456789", 12, 0xbdfcd6eau);
74   run_test("0.11111111111111111111", 22, 0x3de38e39u);
75   run_test("0.0000000000000000000000001", 27, 0x15f79688u);
76 }
77 
78 TEST_F(LlvmLibcStrToFTest, DecimalOutOfRangeTests) {
79   run_test("555E36", 6, 0x7f800000, ERANGE);
80   run_test("1e-10000", 8, 0x0, ERANGE);
81 }
82 
83 TEST_F(LlvmLibcStrToFTest, DecimalsWithRoundingProblems) {
84   run_test("20040229", 8, 0x4b98e512);
85   run_test("20040401", 8, 0x4b98e568);
86   run_test("9E9", 3, 0x50061c46);
87 }
88 
89 TEST_F(LlvmLibcStrToFTest, DecimalSubnormals) {
90   run_test("1.4012984643248170709237295832899161312802619418765e-45", 55, 0x1,
91            ERANGE);
92 }
93 
94 TEST_F(LlvmLibcStrToFTest, DecimalWithLongExponent) {
95   run_test("1e2147483648", 12, 0x7f800000, ERANGE);
96   run_test("1e2147483646", 12, 0x7f800000, ERANGE);
97   run_test("100e2147483646", 14, 0x7f800000, ERANGE);
98   run_test("1e-2147483647", 13, 0x0, ERANGE);
99   run_test("1e-2147483649", 13, 0x0, ERANGE);
100 }
101 
102 TEST_F(LlvmLibcStrToFTest, BasicHexadecimalTests) {
103   run_test("0x1", 3, 0x3f800000);
104   run_test("0x10", 4, 0x41800000);
105   run_test("0x11", 4, 0x41880000);
106   run_test("0x0.1234", 8, 0x3d91a000);
107 }
108 
109 TEST_F(LlvmLibcStrToFTest, HexadecimalSubnormalTests) {
110   run_test("0x0.0000000000000000000000000000000002", 38, 0x4000, ERANGE);
111 
112   // This is the largest subnormal number as represented in hex
113   run_test("0x0.00000000000000000000000000000003fffff8", 42, 0x7fffff, ERANGE);
114 }
115 
116 TEST_F(LlvmLibcStrToFTest, HexadecimalSubnormalRoundingTests) {
117   // This is the largest subnormal number that gets rounded down to 0 (as a
118   // float)
119   run_test("0x0.00000000000000000000000000000000000004", 42, 0x0, ERANGE);
120 
121   // This is slightly larger, and thus rounded up
122   run_test("0x0.000000000000000000000000000000000000041", 43, 0x00000001,
123            ERANGE);
124 
125   // These check that we're rounding to even properly
126   run_test("0x0.0000000000000000000000000000000000000b", 42, 0x00000001,
127            ERANGE);
128   run_test("0x0.0000000000000000000000000000000000000c", 42, 0x00000002,
129            ERANGE);
130 
131   // These check that we're rounding to even properly even when the input bits
132   // are longer than the bit fields can contain.
133   run_test("0x1.000000000000000000000p-150", 30, 0x00000000, ERANGE);
134   run_test("0x1.000010000000000001000p-150", 30, 0x00000001, ERANGE);
135   run_test("0x1.000100000000000001000p-134", 30, 0x00008001, ERANGE);
136   run_test("0x1.FFFFFC000000000001000p-127", 30, 0x007FFFFF, ERANGE);
137   run_test("0x1.FFFFFE000000000000000p-127", 30, 0x00800000);
138 }
139 
140 TEST_F(LlvmLibcStrToFTest, HexadecimalNormalRoundingTests) {
141   // This also checks the round to even behavior by checking three adjacent
142   // numbers.
143   // This gets rounded down to even
144   run_test("0x123456500", 11, 0x4f91a2b2);
145   // This doesn't get rounded at all
146   run_test("0x123456600", 11, 0x4f91a2b3);
147   // This gets rounded up to even
148   run_test("0x123456700", 11, 0x4f91a2b4);
149   // Correct rounding for long input
150   run_test("0x1.000001000000000000000", 25, 0x3f800000);
151   run_test("0x1.000001000000000000100", 25, 0x3f800001);
152 }
153 
154 TEST_F(LlvmLibcStrToFTest, HexadecimalsWithRoundingProblems) {
155   run_test("0xFFFFFFFF", 10, 0x4f800000);
156 }
157 
158 TEST_F(LlvmLibcStrToFTest, HexadecimalOutOfRangeTests) {
159   run_test("0x123456789123456789123456789123456789", 38, 0x7f800000, ERANGE);
160   run_test("-0x123456789123456789123456789123456789", 39, 0xff800000, ERANGE);
161   run_test("0x0.00000000000000000000000000000000000001", 42, 0x0, ERANGE);
162 }
163 
164 TEST_F(LlvmLibcStrToFTest, InfTests) {
165   run_test("INF", 3, 0x7f800000);
166   run_test("INFinity", 8, 0x7f800000);
167   run_test("infnity", 3, 0x7f800000);
168   run_test("infinit", 3, 0x7f800000);
169   run_test("infinfinit", 3, 0x7f800000);
170   run_test("innf", 0, 0x0);
171   run_test("-inf", 4, 0xff800000);
172   run_test("-iNfInItY", 9, 0xff800000);
173 }
174 
175 TEST_F(LlvmLibcStrToFTest, SimpleNaNTests) {
176   run_test("NaN", 3, 0x7fc00000);
177   run_test("-nAn", 4, 0xffc00000);
178 }
179 
180 // These NaNs are of the form `NaN(n-character-sequence)` where the
181 // n-character-sequence is 0 or more letters or numbers. If there is anything
182 // other than a letter or a number, then the valid number is just `NaN`. If
183 // the sequence is valid, then the interpretation of them is implementation
184 // defined, in this case it's passed to strtoll with an automatic base, and
185 // the result is put into the mantissa if it takes up the whole width of the
186 // parentheses.
187 TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesEmptyTest) {
188   run_test("NaN()", 5, 0x7fc00000);
189 }
190 
191 TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidNumberTests) {
192   run_test("NaN(1234)", 9, 0x7fc004d2);
193   run_test("NaN(0x1234)", 11, 0x7fc01234);
194   run_test("NaN(01234)", 10, 0x7fc0029c);
195 }
196 
197 TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesInvalidSequenceTests) {
198   run_test("NaN( 1234)", 3, 0x7fc00000);
199   run_test("NaN(-1234)", 3, 0x7fc00000);
200   run_test("NaN(asd&f)", 3, 0x7fc00000);
201   run_test("NaN(123 )", 3, 0x7fc00000);
202   run_test("NaN(123+asdf)", 3, 0x7fc00000);
203   run_test("NaN(123", 3, 0x7fc00000);
204 }
205 
206 TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidSequenceInvalidNumberTests) {
207   run_test("NaN(1a)", 7, 0x7fc00000);
208   run_test("NaN(asdf)", 9, 0x7fc00000);
209   run_test("NaN(1A1)", 8, 0x7fc00000);
210 }
211