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