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