[libc-commits] [libc] 5dafe9d - [libc] Reduce direct use of errno in src/stdlib and src/__support tests. (#143767)
via libc-commits
libc-commits at lists.llvm.org
Wed Jun 11 12:23:20 PDT 2025
Author: Alexey Samsonov
Date: 2025-06-11T12:23:17-07:00
New Revision: 5dafe9dca867b90f20dcd71c620ad823aee4262b
URL: https://github.com/llvm/llvm-project/commit/5dafe9dca867b90f20dcd71c620ad823aee4262b
DIFF: https://github.com/llvm/llvm-project/commit/5dafe9dca867b90f20dcd71c620ad823aee4262b.diff
LOG: [libc] Reduce direct use of errno in src/stdlib and src/__support tests. (#143767)
* Get rid of libc_errno assignments in str_to_* __support tests, since
those API have been migrated to return error in a struct instead.
* Migrate tests for atof and to strto* functions from <stdlib.h> and for
strdup from <string.h> to use ErrnoCheckingTest harness.
Added:
Modified:
libc/test/src/__support/CMakeLists.txt
libc/test/src/__support/str_to_double_test.cpp
libc/test/src/__support/str_to_float_test.cpp
libc/test/src/__support/str_to_fp_test.h
libc/test/src/__support/str_to_integer_test.cpp
libc/test/src/stdlib/CMakeLists.txt
libc/test/src/stdlib/StrtolTest.h
libc/test/src/stdlib/atof_test.cpp
libc/test/src/stdlib/strtod_test.cpp
libc/test/src/stdlib/strtof_test.cpp
libc/test/src/stdlib/strtold_test.cpp
libc/test/src/string/CMakeLists.txt
libc/test/src/string/strdup_test.cpp
Removed:
################################################################################
diff --git a/libc/test/src/__support/CMakeLists.txt b/libc/test/src/__support/CMakeLists.txt
index c1736c8fe59e2..4fb0dae86e5ca 100644
--- a/libc/test/src/__support/CMakeLists.txt
+++ b/libc/test/src/__support/CMakeLists.txt
@@ -127,7 +127,6 @@ add_libc_test(
libc.src.__support.integer_literals
libc.src.__support.str_to_float
libc.src.__support.uint128
- libc.src.errno.errno
)
@@ -140,7 +139,6 @@ add_libc_test(
DEPENDS
libc.src.__support.integer_literals
libc.src.__support.str_to_integer
- libc.src.errno.errno
)
add_libc_test(
diff --git a/libc/test/src/__support/str_to_double_test.cpp b/libc/test/src/__support/str_to_double_test.cpp
index ccfa44f12d8ef..dc503aa16f08c 100644
--- a/libc/test/src/__support/str_to_double_test.cpp
+++ b/libc/test/src/__support/str_to_double_test.cpp
@@ -99,7 +99,6 @@ TEST(LlvmLibcStrToDblTest, SimpleDecimalConversionExtraTypes) {
uint64_t double_output_mantissa = 0;
uint32_t output_exp2 = 0;
- LIBC_NAMESPACE::libc_errno = 0;
auto double_result =
internal::simple_decimal_conversion<double>("123456789012345678900");
diff --git a/libc/test/src/__support/str_to_float_test.cpp b/libc/test/src/__support/str_to_float_test.cpp
index 66f7db742eb45..03ae80fc2ee38 100644
--- a/libc/test/src/__support/str_to_float_test.cpp
+++ b/libc/test/src/__support/str_to_float_test.cpp
@@ -55,7 +55,6 @@ TEST(LlvmLibcStrToFltTest, SimpleDecimalConversionExtraTypes) {
uint32_t float_output_mantissa = 0;
uint32_t output_exp2 = 0;
- LIBC_NAMESPACE::libc_errno = 0;
auto float_result =
internal::simple_decimal_conversion<float>("123456789012345678900");
float_output_mantissa = float_result.num.mantissa;
diff --git a/libc/test/src/__support/str_to_fp_test.h b/libc/test/src/__support/str_to_fp_test.h
index c7bc57b845fe0..d349192f107c0 100644
--- a/libc/test/src/__support/str_to_fp_test.h
+++ b/libc/test/src/__support/str_to_fp_test.h
@@ -10,7 +10,6 @@
#include "src/__support/macros/config.h"
#include "src/__support/str_to_float.h"
#include "src/__support/uint128.h"
-#include "src/errno/libc_errno.h"
#include "test/UnitTest/Test.h"
@@ -67,7 +66,6 @@ template <typename T> struct LlvmLibcStrToFloatTest : public testing::Test {
const int expectedErrno = 0) {
StorageType actual_output_mantissa = 0;
uint32_t actual_output_exp2 = 0;
- LIBC_NAMESPACE::libc_errno = 0;
auto result = internal::simple_decimal_conversion<T>(numStart);
diff --git a/libc/test/src/__support/str_to_integer_test.cpp b/libc/test/src/__support/str_to_integer_test.cpp
index 34b645b4b38c8..1ec882b212b8a 100644
--- a/libc/test/src/__support/str_to_integer_test.cpp
+++ b/libc/test/src/__support/str_to_integer_test.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "src/__support/str_to_integer.h"
-#include "src/errno/libc_errno.h"
#include <stddef.h>
#include "test/UnitTest/Test.h"
diff --git a/libc/test/src/stdlib/CMakeLists.txt b/libc/test/src/stdlib/CMakeLists.txt
index 302971a078c17..45fd49b6d3526 100644
--- a/libc/test/src/stdlib/CMakeLists.txt
+++ b/libc/test/src/stdlib/CMakeLists.txt
@@ -9,6 +9,7 @@ add_libc_test(
DEPENDS
libc.src.errno.errno
libc.src.stdlib.atof
+ libc.test.UnitTest.ErrnoCheckingTest
)
add_header_library(
@@ -64,6 +65,7 @@ add_fp_unittest(
libc.src.errno.errno
libc.src.stdlib.strtod
libc.src.__support.FPUtil.fenv_impl
+ libc.test.UnitTest.ErrnoCheckingTest
)
add_fp_unittest(
@@ -76,6 +78,7 @@ add_fp_unittest(
libc.src.errno.errno
libc.src.stdlib.strtof
libc.src.__support.FPUtil.fenv_impl
+ libc.test.UnitTest.ErrnoCheckingTest
)
add_header_library(
@@ -86,6 +89,7 @@ add_header_library(
libc.src.__support.CPP.limits
libc.src.__support.CPP.type_traits
libc.src.errno.errno
+ libc.test.UnitTest.ErrnoCheckingTest
)
add_libc_test(
@@ -133,6 +137,7 @@ add_libc_test(
libc.src.errno.errno
libc.src.__support.uint128
libc.src.stdlib.strtold
+ libc.test.UnitTest.ErrnoCheckingTest
)
add_libc_test(
diff --git a/libc/test/src/stdlib/StrtolTest.h b/libc/test/src/stdlib/StrtolTest.h
index ed302f14d03ef..03f0a6539c785 100644
--- a/libc/test/src/stdlib/StrtolTest.h
+++ b/libc/test/src/stdlib/StrtolTest.h
@@ -10,7 +10,7 @@
#include "src/__support/CPP/type_traits.h"
#include "src/__support/ctype_utils.h"
#include "src/__support/macros/properties/architectures.h"
-#include "src/errno/libc_errno.h"
+#include "test/UnitTest/ErrnoCheckingTest.h"
#include "test/UnitTest/Test.h"
#include <stddef.h>
@@ -18,7 +18,7 @@
using LIBC_NAMESPACE::cpp::is_signed_v;
template <typename ReturnT>
-struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
+struct StrtoTest : public LIBC_NAMESPACE::testing::ErrnoCheckingTest {
using FunctionT = ReturnT (*)(const char *, char **, int);
static constexpr ReturnT T_MAX =
@@ -28,7 +28,6 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
void InvalidBase(FunctionT func) {
const char *ten = "10";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(ten, nullptr, -1), ReturnT(0));
ASSERT_ERRNO_EQ(EINVAL);
}
@@ -38,23 +37,19 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// TODO: Look into collapsing these repeated segments.
const char *ten = "10";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(ten, &str_end, 10), ReturnT(10));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - ten, ptr
diff _t(2));
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(ten, nullptr, 10), ReturnT(10));
ASSERT_ERRNO_SUCCESS();
const char *hundred = "100";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(hundred, &str_end, 10), ReturnT(100));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - hundred, ptr
diff _t(3));
const char *big_number = "1234567890";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(big_number, &str_end, 10), ReturnT(1234567890));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - big_number, ptr
diff _t(10));
@@ -62,7 +57,6 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// This number is larger than 2^32, meaning that if long is only 32 bits
// wide, strtol will return LONG_MAX.
const char *bigger_number = "12345678900";
- LIBC_NAMESPACE::libc_errno = 0;
if constexpr (sizeof(ReturnT) < 8) {
ASSERT_EQ(func(bigger_number, &str_end, 10), T_MAX);
ASSERT_ERRNO_EQ(ERANGE);
@@ -73,14 +67,12 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
EXPECT_EQ(str_end - bigger_number, ptr
diff _t(11));
const char *too_big_number = "123456789012345678901";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(too_big_number, &str_end, 10), T_MAX);
ASSERT_ERRNO_EQ(ERANGE);
EXPECT_EQ(str_end - too_big_number, ptr
diff _t(21));
const char *long_number_range_test =
"10000000000000000000000000000000000000000000000000";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(long_number_range_test, &str_end, 10), T_MAX);
ASSERT_ERRNO_EQ(ERANGE);
EXPECT_EQ(str_end - long_number_range_test, ptr
diff _t(50));
@@ -88,19 +80,16 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// For most negative numbers, the unsigned functions treat it the same as
// casting a negative variable to an unsigned type.
const char *negative = "-100";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(negative, &str_end, 10), ReturnT(-100));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - negative, ptr
diff _t(4));
const char *big_negative_number = "-1234567890";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(big_negative_number, &str_end, 10), ReturnT(-1234567890));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - big_negative_number, ptr
diff _t(11));
const char *too_big_negative_number = "-123456789012345678901";
- LIBC_NAMESPACE::libc_errno = 0;
// If the number is signed, it should return the smallest negative number
// for the current type, but if it's unsigned it should max out and return
// the largest positive number for the current type. From the standard:
@@ -118,73 +107,61 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
char *str_end = nullptr;
const char *spaces_before = " 10";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(spaces_before, &str_end, 10), ReturnT(10));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - spaces_before, ptr
diff _t(7));
const char *spaces_after = "10 ";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(spaces_after, &str_end, 10), ReturnT(10));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - spaces_after, ptr
diff _t(2));
const char *word_before = "word10";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(word_before, &str_end, 10), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - word_before, ptr
diff _t(0));
const char *word_after = "10word";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(word_after, &str_end, 10), ReturnT(10));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - word_after, ptr
diff _t(2));
const char *two_numbers = "10 999";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(two_numbers, &str_end, 10), ReturnT(10));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - two_numbers, ptr
diff _t(2));
const char *two_signs = "--10 999";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(two_signs, &str_end, 10), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - two_signs, ptr
diff _t(0));
const char *sign_before = "+2=4";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(sign_before, &str_end, 10), ReturnT(2));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - sign_before, ptr
diff _t(2));
const char *sign_after = "2+2=4";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(sign_after, &str_end, 10), ReturnT(2));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - sign_after, ptr
diff _t(1));
const char *tab_before = "\t10";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(tab_before, &str_end, 10), ReturnT(10));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - tab_before, ptr
diff _t(3));
const char *all_together = "\t -12345and+67890";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(all_together, &str_end, 10), ReturnT(-12345));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - all_together, ptr
diff _t(9));
const char *just_spaces = " ";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(just_spaces, &str_end, 10), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_spaces, ptr
diff _t(0));
const char *just_space_and_sign = " +";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(just_space_and_sign, &str_end, 10), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_space_and_sign, ptr
diff _t(0));
@@ -203,12 +180,10 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
small_string[0] = static_cast<char>(
LIBC_NAMESPACE::internal::int_to_b36_char(first_digit));
if (first_digit < base) {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(first_digit));
ASSERT_ERRNO_SUCCESS();
} else {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
}
@@ -223,18 +198,15 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
small_string[1] = static_cast<char>(
LIBC_NAMESPACE::internal::int_to_b36_char(second_digit));
if (first_digit < base && second_digit < base) {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(
func(small_string, nullptr, base),
static_cast<ReturnT>(second_digit + (first_digit * base)));
ASSERT_ERRNO_SUCCESS();
} else if (first_digit < base) {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(first_digit));
ASSERT_ERRNO_SUCCESS();
} else {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
}
@@ -255,14 +227,12 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
if (first_digit < base && second_digit < base &&
third_digit < base) {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(third_digit +
(second_digit * base) +
(first_digit * base * base)));
ASSERT_ERRNO_SUCCESS();
} else if (first_digit < base && second_digit < base) {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(
func(small_string, nullptr, base),
static_cast<ReturnT>(second_digit + (first_digit * base)));
@@ -272,23 +242,19 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// The number is treated as a one digit hexadecimal.
if (base == 16 && first_digit == 0 && second_digit == 33) {
if (third_digit < base) {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(third_digit));
ASSERT_ERRNO_SUCCESS();
} else {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
}
} else {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(first_digit));
ASSERT_ERRNO_SUCCESS();
}
} else {
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
}
@@ -302,19 +268,16 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
char *str_end = nullptr;
const char *no_prefix = "123abc";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(no_prefix, &str_end, 16), ReturnT(0x123abc));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - no_prefix, ptr
diff _t(6));
const char *yes_prefix = "0x456def";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(yes_prefix, &str_end, 16), ReturnT(0x456def));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - yes_prefix, ptr
diff _t(8));
const char *letter_after_prefix = "0xabc123";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(letter_after_prefix, &str_end, 16), ReturnT(0xabc123));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - letter_after_prefix, ptr
diff _t(8));
@@ -325,7 +288,6 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// Max size for unsigned 32 bit numbers
const char *max_32_bit_value = "0xFFFFFFFF";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(max_32_bit_value, &str_end, 0),
((is_signed_v<ReturnT> && sizeof(ReturnT) == 4)
? T_MAX
@@ -334,7 +296,6 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
EXPECT_EQ(str_end - max_32_bit_value, ptr
diff _t(10));
const char *negative_max_32_bit_value = "-0xFFFFFFFF";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(negative_max_32_bit_value, &str_end, 0),
((is_signed_v<ReturnT> && sizeof(ReturnT) == 4)
? T_MIN
@@ -345,13 +306,11 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// Max size for signed 32 bit numbers
const char *max_31_bit_value = "0x7FFFFFFF";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(max_31_bit_value, &str_end, 0), ReturnT(0x7FFFFFFF));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - max_31_bit_value, ptr
diff _t(10));
const char *negative_max_31_bit_value = "-0x7FFFFFFF";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(negative_max_31_bit_value, &str_end, 0),
-ReturnT(0x7FFFFFFF));
ASSERT_ERRNO_SUCCESS();
@@ -360,7 +319,6 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// Max size for unsigned 64 bit numbers
const char *max_64_bit_value = "0xFFFFFFFFFFFFFFFF";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(max_64_bit_value, &str_end, 0),
(is_signed_v<ReturnT> || sizeof(ReturnT) < 8
? T_MAX
@@ -371,7 +329,6 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// 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_NAMESPACE::libc_errno = 0;
ASSERT_EQ(
func(negative_max_64_bit_value, &str_end, 0),
(is_signed_v<ReturnT>
@@ -383,14 +340,12 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// Max size for signed 64 bit numbers
const char *max_63_bit_value = "0x7FFFFFFFFFFFFFFF";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(max_63_bit_value, &str_end, 0),
(sizeof(ReturnT) < 8 ? T_MAX : ReturnT(0x7FFFFFFFFFFFFFFF)));
ASSERT_ERRNO_EQ(sizeof(ReturnT) < 8 ? ERANGE : 0);
EXPECT_EQ(str_end - max_63_bit_value, ptr
diff _t(18));
const char *negative_max_63_bit_value = "-0x7FFFFFFFFFFFFFFF";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(negative_max_63_bit_value, &str_end, 0),
(sizeof(ReturnT) >= 8 ? -ReturnT(0x7FFFFFFFFFFFFFFF)
: (is_signed_v<ReturnT> ? T_MIN : T_MAX)));
@@ -402,23 +357,19 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
char *str_end = nullptr;
const char *just_prefix = "0x";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(just_prefix, &str_end, 16), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_prefix, ptr
diff _t(1));
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(just_prefix, &str_end, 0), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_prefix, ptr
diff _t(1));
const char *prefix_with_x_after = "0xx";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(prefix_with_x_after, &str_end, 16), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - prefix_with_x_after, ptr
diff _t(1));
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(prefix_with_x_after, &str_end, 0), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - prefix_with_x_after, ptr
diff _t(1));
@@ -428,43 +379,36 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
char *str_end = nullptr;
const char *base_ten = "12345";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(base_ten, &str_end, 0), ReturnT(12345));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_ten, ptr
diff _t(5));
const char *base_sixteen_no_prefix = "123abc";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(base_sixteen_no_prefix, &str_end, 0), ReturnT(123));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_sixteen_no_prefix, ptr
diff _t(3));
const char *base_sixteen_with_prefix = "0x456def";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(base_sixteen_with_prefix, &str_end, 0), ReturnT(0x456def));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_sixteen_with_prefix, ptr
diff _t(8));
const char *base_eight_with_prefix = "012345";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(base_eight_with_prefix, &str_end, 0), ReturnT(012345));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_eight_with_prefix, ptr
diff _t(6));
const char *just_zero = "0";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(just_zero, &str_end, 0), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_zero, ptr
diff _t(1));
const char *just_zero_x = "0x";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(just_zero_x, &str_end, 0), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_zero_x, ptr
diff _t(1));
const char *just_zero_eight = "08";
- LIBC_NAMESPACE::libc_errno = 0;
ASSERT_EQ(func(just_zero_eight, &str_end, 0), ReturnT(0));
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_zero_eight, ptr
diff _t(1));
diff --git a/libc/test/src/stdlib/atof_test.cpp b/libc/test/src/stdlib/atof_test.cpp
index 1e4259b792d7e..92b904ecad94e 100644
--- a/libc/test/src/stdlib/atof_test.cpp
+++ b/libc/test/src/stdlib/atof_test.cpp
@@ -7,29 +7,28 @@
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
-#include "src/errno/libc_errno.h"
#include "src/stdlib/atof.h"
+#include "test/UnitTest/ErrnoCheckingTest.h"
#include "test/UnitTest/ErrnoSetterMatcher.h"
#include "test/UnitTest/Test.h"
#include <stddef.h>
+using LlvmLibcAToFTest = LIBC_NAMESPACE::testing::ErrnoCheckingTest;
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
// This is just a simple test to make sure that this function works at all. It's
// functionally identical to strtod so the bulk of the testing is there.
-TEST(LlvmLibcAToFTest, SimpleTest) {
+TEST_F(LlvmLibcAToFTest, SimpleTest) {
LIBC_NAMESPACE::fputil::FPBits<double> expected_fp =
LIBC_NAMESPACE::fputil::FPBits<double>(uint64_t(0x405ec00000000000));
- LIBC_NAMESPACE::libc_errno = 0;
EXPECT_THAT(LIBC_NAMESPACE::atof("123"),
Succeeds<double>(expected_fp.get_val()));
}
-TEST(LlvmLibcAToFTest, FailedParsingTest) {
- LIBC_NAMESPACE::libc_errno = 0;
+TEST_F(LlvmLibcAToFTest, FailedParsingTest) {
// atof does not flag errors.
EXPECT_THAT(LIBC_NAMESPACE::atof("???"), Succeeds<double>(0.0));
}
diff --git a/libc/test/src/stdlib/strtod_test.cpp b/libc/test/src/stdlib/strtod_test.cpp
index 92d14640e6533..db3c1d73bd22e 100644
--- a/libc/test/src/stdlib/strtod_test.cpp
+++ b/libc/test/src/stdlib/strtod_test.cpp
@@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
-#include "src/errno/libc_errno.h"
#include "src/stdlib/strtod.h"
+#include "test/UnitTest/ErrnoCheckingTest.h"
#include "test/UnitTest/ErrnoSetterMatcher.h"
#include "test/UnitTest/RoundingModeUtils.h"
#include "test/UnitTest/Test.h"
@@ -22,7 +22,7 @@ using LIBC_NAMESPACE::fputil::testing::RoundingMode;
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Fails;
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
-class LlvmLibcStrToDTest : public LIBC_NAMESPACE::testing::Test,
+class LlvmLibcStrToDTest : public LIBC_NAMESPACE::testing::ErrnoCheckingTest,
ForceRoundingModeTest<RoundingMode::Nearest> {
public:
void run_test(const char *inputString, const ptr
diff _t expectedStrLen,
@@ -46,7 +46,6 @@ class LlvmLibcStrToDTest : public LIBC_NAMESPACE::testing::Test,
LIBC_NAMESPACE::fputil::FPBits<double> expected_fp =
LIBC_NAMESPACE::fputil::FPBits<double>(expectedRawData);
- LIBC_NAMESPACE::libc_errno = 0;
double result = LIBC_NAMESPACE::strtod(inputString, &str_end);
if (expectedErrno == 0)
EXPECT_THAT(result, Succeeds<double>(expected_fp.get_val()));
diff --git a/libc/test/src/stdlib/strtof_test.cpp b/libc/test/src/stdlib/strtof_test.cpp
index 6a716c956291c..6df1ddda93bfa 100644
--- a/libc/test/src/stdlib/strtof_test.cpp
+++ b/libc/test/src/stdlib/strtof_test.cpp
@@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
-#include "src/errno/libc_errno.h"
#include "src/stdlib/strtof.h"
+#include "test/UnitTest/ErrnoCheckingTest.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/RoundingModeUtils.h"
#include "test/UnitTest/Test.h"
@@ -19,7 +19,7 @@
using LIBC_NAMESPACE::fputil::testing::ForceRoundingModeTest;
using LIBC_NAMESPACE::fputil::testing::RoundingMode;
-class LlvmLibcStrToFTest : public LIBC_NAMESPACE::testing::Test,
+class LlvmLibcStrToFTest : public LIBC_NAMESPACE::testing::ErrnoCheckingTest,
ForceRoundingModeTest<RoundingMode::Nearest> {
public:
void run_test(const char *inputString, const ptr
diff _t expectedStrLen,
@@ -43,7 +43,6 @@ class LlvmLibcStrToFTest : public LIBC_NAMESPACE::testing::Test,
LIBC_NAMESPACE::fputil::FPBits<float> expected_fp =
LIBC_NAMESPACE::fputil::FPBits<float>(expectedRawData);
- LIBC_NAMESPACE::libc_errno = 0;
float result = LIBC_NAMESPACE::strtof(inputString, &str_end);
EXPECT_EQ(str_end - inputString, expectedStrLen);
diff --git a/libc/test/src/stdlib/strtold_test.cpp b/libc/test/src/stdlib/strtold_test.cpp
index b209c85b88e36..eb4056dc7ba64 100644
--- a/libc/test/src/stdlib/strtold_test.cpp
+++ b/libc/test/src/stdlib/strtold_test.cpp
@@ -8,9 +8,9 @@
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/uint128.h"
-#include "src/errno/libc_errno.h"
#include "src/stdlib/strtold.h"
+#include "test/UnitTest/ErrnoCheckingTest.h"
#include "test/UnitTest/Test.h"
#include <stddef.h>
@@ -25,7 +25,7 @@
#error "Unknown long double type"
#endif
-class LlvmLibcStrToLDTest : public LIBC_NAMESPACE::testing::Test {
+class LlvmLibcStrToLDTest : public LIBC_NAMESPACE::testing::ErrnoCheckingTest {
public:
#if defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
void run_test(const char *inputString, const ptr
diff _t expectedStrLen,
@@ -80,7 +80,6 @@ class LlvmLibcStrToLDTest : public LIBC_NAMESPACE::testing::Test {
FPBits(static_cast<FPBits::StorageType>(expectedRawData));
const int expected_errno = expectedErrno;
- LIBC_NAMESPACE::libc_errno = 0;
long double result = LIBC_NAMESPACE::strtold(inputString, &str_end);
LIBC_NAMESPACE::fputil::FPBits<long double> actual_fp =
diff --git a/libc/test/src/string/CMakeLists.txt b/libc/test/src/string/CMakeLists.txt
index a675373938e99..ced60750a45c7 100644
--- a/libc/test/src/string/CMakeLists.txt
+++ b/libc/test/src/string/CMakeLists.txt
@@ -168,6 +168,7 @@ add_libc_test(
DEPENDS
libc.src.string.strdup
libc.src.errno.errno
+ libc.test.UnitTest.ErrnoCheckingTest
)
# FIXME: This is failing on the bot for some reason, disable for now.
diff --git a/libc/test/src/string/strdup_test.cpp b/libc/test/src/string/strdup_test.cpp
index 20b85c37637dd..4b18fc7f1bdee 100644
--- a/libc/test/src/string/strdup_test.cpp
+++ b/libc/test/src/string/strdup_test.cpp
@@ -6,14 +6,15 @@
//
//===----------------------------------------------------------------------===//
-#include "src/errno/libc_errno.h"
#include "src/string/strdup.h"
+#include "test/UnitTest/ErrnoCheckingTest.h"
#include "test/UnitTest/Test.h"
-TEST(LlvmLibcStrDupTest, EmptyString) {
+using LlvmLibcStrDupTest = LIBC_NAMESPACE::testing::ErrnoCheckingTest;
+
+TEST_F(LlvmLibcStrDupTest, EmptyString) {
const char *empty = "";
- LIBC_NAMESPACE::libc_errno = 0;
char *result = LIBC_NAMESPACE::strdup(empty);
ASSERT_ERRNO_SUCCESS();
@@ -23,10 +24,9 @@ TEST(LlvmLibcStrDupTest, EmptyString) {
::free(result);
}
-TEST(LlvmLibcStrDupTest, AnyString) {
+TEST_F(LlvmLibcStrDupTest, AnyString) {
const char *abc = "abc";
- LIBC_NAMESPACE::libc_errno = 0;
char *result = LIBC_NAMESPACE::strdup(abc);
ASSERT_ERRNO_SUCCESS();
@@ -36,8 +36,7 @@ TEST(LlvmLibcStrDupTest, AnyString) {
::free(result);
}
-TEST(LlvmLibcStrDupTest, NullPtr) {
- LIBC_NAMESPACE::libc_errno = 0;
+TEST_F(LlvmLibcStrDupTest, NullPtr) {
char *result = LIBC_NAMESPACE::strdup(nullptr);
ASSERT_ERRNO_SUCCESS();
More information about the libc-commits
mailing list