libc/test/src/stdlib/strtof_test.cpp

   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 }