caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[libc] Reduce direct use of errno in src/stdlib and src/__support tests. (#143767)

Browse Source 
* 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.
This commit is contained in:
Alexey Samsonov
2025-06-11 12:23:17 -07:00
committed by GitHub
parent d5f68cb145
commit 5dafe9dca8
13 changed files with 24 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libc/test/src/__support/CMakeLists.txt
View File

@@ -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(

1
libc/test/src/__support/str_to_double_test.cpp
View File

@@ -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");

1
libc/test/src/__support/str_to_float_test.cpp
View File

@@ -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;

2
libc/test/src/__support/str_to_fp_test.h
View File

@@ -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);

1
libc/test/src/__support/str_to_integer_test.cpp
View File

@@ -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"

5
libc/test/src/stdlib/CMakeLists.txt
View File

@@ -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(

60
libc/test/src/stdlib/StrtolTest.h
View File

@@ -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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_t(1));

9
libc/test/src/stdlib/atof_test.cpp
View File

@@ -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));
}

5
libc/test/src/stdlib/strtod_test.cpp
View File

@@ -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 ptrdiff_t expectedStrLen,
@@ -46,7 +46,6 @@ public:
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()));

5
libc/test/src/stdlib/strtof_test.cpp
View File

@@ -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 ptrdiff_t expectedStrLen,
@@ -43,7 +43,6 @@ public:
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);

5
libc/test/src/stdlib/strtold_test.cpp
View File

@@ -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 ptrdiff_t expectedStrLen,
@@ -80,7 +80,6 @@ public:
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 =

1
libc/test/src/string/CMakeLists.txt
View File

@@ -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.

13
libc/test/src/string/strdup_test.cpp
View File

@@ -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();