[libc] Add strtoint32 and strtoint64 tests

[michaelrj]

Summary

There were regressions in the testing framework due to none of the
functioning buildbots having a 32 bit long. This allowed the 32 bit
version of the strtointeger function to go untested. This patch adds
tests for strtoint32 and strtoint64, which are internal testing
functions that use constant integer sizes. It also fixes the tests to
properly handle these situations.

[sivachandra]

libc/test/src/stdlib/strtoint64_test.cpp

34

Nit: Not sure if we want to call the internal function or if we should do something like:

if constexpr (cpp::is_same_v<int64_t, long>)
  result = __llvm_libc::strtol(...);
else
  result = __llvm_libc::strtoll(...);

[michaelrj]

libc/test/src/stdlib/strtoint64_test.cpp

34

Neither long nor long long are guaranteed to be 64 bits, so I think it's safer to just template this with the specific bits we want.

libc/test/src/stdlib/CMakeLists.txt

HDRS
     StrtolTest.h
   DEPENDS
     libc.src.__support.CPP.limits
     libc.src.__support.CPP.type_traits
     libc.src.errno.errno
 )
 
 add_libc_test(
+  strtoint32_test
+  SUITE
+    libc-stdlib-tests
+  SRCS
+    strtoint32_test.cpp
+  DEPENDS
+    libc.src.__support.str_to_integer
+    libc.src.errno.errno
+    .strtol_test_support
+)
+
+add_libc_test(
+  strtoint64_test
+  SUITE
+    libc-stdlib-tests
+  SRCS
+    strtoint64_test.cpp
+  DEPENDS
+    libc.src.__support.str_to_integer
+    libc.src.errno.errno
+    .strtol_test_support
+)
+
+add_libc_test(
   strtol_test
   SUITE
     libc-stdlib-tests
   SRCS
     strtol_test.cpp
   DEPENDS
     libc.src.stdlib.strtol
     .strtol_test_support

libc/test/src/stdlib/StrtolTest.h

void CleanBaseSixteenDecode(FunctionT func) {
     // Max size for unsigned 32 bit numbers
 
     const char *max_32_bit_value = "0xFFFFFFFF";
     libc_errno = 0;
     ASSERT_EQ(func(max_32_bit_value, &str_end, 0),
               ((is_signed_v<ReturnT> && sizeof(ReturnT) == 4)
                    ? T_MAX
                    : ReturnT(0xFFFFFFFF)));
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(libc_errno,
+              is_signed_v<ReturnT> && sizeof(ReturnT) == 4 ? ERANGE : 0);
     EXPECT_EQ(str_end - max_32_bit_value, ptrdiff_t(10));
 
     const char *negative_max_32_bit_value = "-0xFFFFFFFF";
     libc_errno = 0;
     ASSERT_EQ(func(negative_max_32_bit_value, &str_end, 0),
               ((is_signed_v<ReturnT> && sizeof(ReturnT) == 4)
                    ? T_MIN
                    : -ReturnT(0xFFFFFFFF)));
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(libc_errno,
+              is_signed_v<ReturnT> && sizeof(ReturnT) == 4 ? ERANGE : 0);
     EXPECT_EQ(str_end - negative_max_32_bit_value, ptrdiff_t(11));
 
     // Max size for signed 32 bit numbers
 
     const char *max_31_bit_value = "0x7FFFFFFF";
     libc_errno = 0;
     ASSERT_EQ(func(max_31_bit_value, &str_end, 0), ReturnT(0x7FFFFFFF));
     ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - max_31_bit_value, ptrdiff_t(10));
 
     const char *negative_max_31_bit_value = "-0x7FFFFFFF";
     libc_errno = 0;
     ASSERT_EQ(func(negative_max_31_bit_value, &str_end, 0),
               -ReturnT(0x7FFFFFFF));
     ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - negative_max_31_bit_value, ptrdiff_t(11));
 
     // Max size for unsigned 64 bit numbers
 
     const char *max_64_bit_value = "0xFFFFFFFFFFFFFFFF";
     libc_errno = 0;
     ASSERT_EQ(func(max_64_bit_value, &str_end, 0),
-              (is_signed_v<ReturnT> ? T_MAX : ReturnT(0xFFFFFFFFFFFFFFFF)));
-    ASSERT_EQ(libc_errno, (is_signed_v<ReturnT> ? ERANGE : 0));
+              (is_signed_v<ReturnT> || sizeof(ReturnT) < 8
+                   ? T_MAX
+                   : ReturnT(0xFFFFFFFFFFFFFFFF)));
+    ASSERT_EQ(libc_errno,
+              (is_signed_v<ReturnT> || sizeof(ReturnT) < 8 ? ERANGE : 0));
     EXPECT_EQ(str_end - max_64_bit_value, ptrdiff_t(18));
 
+    // See the end of CleanBase10Decode for an explanation of how this large
+    // negative number can end up as T_MAX.
     const char *negative_max_64_bit_value = "-0xFFFFFFFFFFFFFFFF";
     libc_errno = 0;
-    ASSERT_EQ(func(negative_max_64_bit_value, &str_end, 0),
-              (is_signed_v<ReturnT> ? T_MIN : -ReturnT(0xFFFFFFFFFFFFFFFF)));
-    ASSERT_EQ(libc_errno, (is_signed_v<ReturnT> ? ERANGE : 0));
+    ASSERT_EQ(
+        func(negative_max_64_bit_value, &str_end, 0),
+        (is_signed_v<ReturnT>
+             ? T_MIN
+             : (sizeof(ReturnT) < 8 ? T_MAX : -ReturnT(0xFFFFFFFFFFFFFFFF))));
+    ASSERT_EQ(libc_errno,
+              (is_signed_v<ReturnT> || sizeof(ReturnT) < 8 ? ERANGE : 0));
     EXPECT_EQ(str_end - negative_max_64_bit_value, ptrdiff_t(19));
 
     // Max size for signed 64 bit numbers
 
     const char *max_63_bit_value = "0x7FFFFFFFFFFFFFFF";
     libc_errno = 0;
-    ASSERT_EQ(func(max_63_bit_value, &str_end, 0), ReturnT(0x7FFFFFFFFFFFFFFF));
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(func(max_63_bit_value, &str_end, 0),
+              (sizeof(ReturnT) < 8 ? T_MAX : ReturnT(0x7FFFFFFFFFFFFFFF)));
+    ASSERT_EQ(libc_errno, sizeof(ReturnT) < 8 ? ERANGE : 0);
     EXPECT_EQ(str_end - max_63_bit_value, ptrdiff_t(18));
 
     const char *negative_max_63_bit_value = "-0x7FFFFFFFFFFFFFFF";
     libc_errno = 0;
     ASSERT_EQ(func(negative_max_63_bit_value, &str_end, 0),
-              -ReturnT(0x7FFFFFFFFFFFFFFF));
-    ASSERT_EQ(libc_errno, 0);
+              (sizeof(ReturnT) >= 8 ? -ReturnT(0x7FFFFFFFFFFFFFFF)
+                                    : (is_signed_v<ReturnT> ? T_MIN : T_MAX)));
+    ASSERT_EQ(libc_errno, sizeof(ReturnT) < 8 ? ERANGE : 0);
     EXPECT_EQ(str_end - negative_max_63_bit_value, ptrdiff_t(19));
   }
 
   void MessyBaseSixteenDecode(FunctionT func) {
     char *str_end = nullptr;
 
     const char *just_prefix = "0x";
     libc_errno = 0;

libc/test/src/stdlib/atoi_test.cpp

-//===-- Unittests for atoi -----------------------------------------------===//
+//===-- Unittests for atoi ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AtoiTest.h"
 
 #include "src/stdlib/atoi.h"
 
 #include "test/UnitTest/Test.h"
 
 ATOI_TEST(Atoi, __llvm_libc::atoi)

libc/test/src/stdlib/atol_test.cpp

-//===-- Unittests for atol -----------------------------------------------===//
+//===-- Unittests for atol ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AtoiTest.h"
 
 #include "src/stdlib/atol.h"
 
 #include "test/UnitTest/Test.h"
 
 ATOI_TEST(Atol, __llvm_libc::atol)

libc/test/src/stdlib/strtod_test.cpp

-//===-- Unittests for strtod ---------------------------------------------===//
+//===-- Unittests for strtod ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/FPUtil/FPBits.h"

libc/test/src/stdlib/strtof_test.cpp

-//===-- Unittests for strtof ---------------------------------------------===//
+//===-- Unittests for strtof ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/FPUtil/FPBits.h"

libc/test/src/stdlib/strtoint32_test.cpp

+//===-- Unittests for strtoint32 ------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+
+#include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
+
+#include "StrtolTest.h"
+#include "test/UnitTest/Test.h"
+
+namespace __llvm_libc {
+
+int32_t strtoint32(const char *__restrict str, char **__restrict str_end,
+                   int base) {
+  auto result = internal::strtointeger<int32_t>(str, base);
+  if (result.has_error())
+    libc_errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
+}
+
+uint32_t strtouint32(const char *__restrict str, char **__restrict str_end,
+                     int base) {
+  auto result = internal::strtointeger<uint32_t>(str, base);
+  if (result.has_error())
+    libc_errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
+}
+} // namespace __llvm_libc
+
+STRTOL_TEST(Strtoint32, __llvm_libc::strtoint32)
+STRTOL_TEST(Strtouint32, __llvm_libc::strtouint32)

libc/test/src/stdlib/strtoint64_test.cpp

+//===-- Unittests for strtoint64 ------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+
+#include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
+
+#include "StrtolTest.h"
+#include "test/UnitTest/Test.h"
+
+namespace __llvm_libc {
+
+int64_t strtoint64(const char *__restrict str, char **__restrict str_end,
+                   int base) {
+  auto result = internal::strtointeger<int64_t>(str, base);
+  if (result.has_error())
+    libc_errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
+}
+
+uint64_t strtouint64(const char *__restrict str, char **__restrict str_end,
+                     int base) {
+  auto result = internal::strtointeger<uint64_t>(str, base);
+  if (result.has_error())
+    libc_errno = result.error;
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(str + result.parsed_len);
+
+  return result;
+}
+} // namespace __llvm_libc
+
+STRTOL_TEST(Strtoint64, __llvm_libc::strtoint64)
+STRTOL_TEST(Strtouint64, __llvm_libc::strtouint64)

libc/test/src/stdlib/strtol_test.cpp

-//===-- Unittests for strtol ---------------------------------------------===//
+//===-- Unittests for strtol ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdlib/strtol.h"
 
 #include "test/UnitTest/Test.h"
 
 #include "StrtolTest.h"
 
 STRTOL_TEST(Strtol, __llvm_libc::strtol)