34 changes: 17 additions & 17 deletions libc/test/src/sched/param_and_scheduler_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,35 +41,35 @@ class SchedTest : public LIBC_NAMESPACE::testing::Test {

int init_policy = LIBC_NAMESPACE::sched_getscheduler(0);
ASSERT_GE(init_policy, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_GE(max_priority, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_GE(min_priority, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

struct sched_param param = {min_priority};

// Negative pid
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(-1, policy, &param), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

ASSERT_EQ(LIBC_NAMESPACE::sched_getscheduler(-1), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

// Invalid Policy
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(0, policy | 128, &param), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

// Out of bounds priority
param.sched_priority = min_priority - 1;
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(0, policy, &param), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

param.sched_priority = max_priority + 1;
Expand All @@ -90,33 +90,33 @@ class SchedTest : public LIBC_NAMESPACE::testing::Test {

ASSERT_EQ(LIBC_NAMESPACE::sched_getscheduler(0),
can_set ? policy : init_policy);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

// Out of bounds priority
param.sched_priority = -1;
ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(0, &param), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

param.sched_priority = max_priority + 1;
ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(0, &param), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

for (int priority = min_priority; priority <= max_priority; ++priority) {
ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(0, &param), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
int init_priority = param.sched_priority;

param.sched_priority = priority;

// Negative pid
ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(-1, &param), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(-1, &param), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

// Success / missing permissions
Expand All @@ -126,14 +126,14 @@ class SchedTest : public LIBC_NAMESPACE::testing::Test {
libc_errno = 0;

ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(0, &param), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_EQ(param.sched_priority, can_set ? priority : init_priority);
}

// Null test
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(0, policy, nullptr), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
}
};
Expand All @@ -155,10 +155,10 @@ TEST(LlvmLibcSchedParamAndSchedulerTest, NullParamTest) {
libc_errno = 0;

ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(0, nullptr), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;

ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(0, nullptr), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
}
14 changes: 7 additions & 7 deletions libc/test/src/sched/sched_rr_get_interval_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,11 +21,11 @@ TEST(LlvmLibcSchedRRGetIntervalTest, SmokeTest) {
auto SetSched = [&](int policy) {
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_GE(min_priority, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
struct sched_param param;
param.sched_priority = min_priority;
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(0, policy, &param), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
};

auto TimespecToNs = [](struct timespec t) {
Expand All @@ -41,13 +41,13 @@ TEST(LlvmLibcSchedRRGetIntervalTest, SmokeTest) {

int cur_policy = LIBC_NAMESPACE::sched_getscheduler(0);
ASSERT_GE(cur_policy, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

// We can actually run meaningful tests.
if (cur_policy == SCHED_RR) {
// Success
ASSERT_EQ(LIBC_NAMESPACE::sched_rr_get_interval(0, &ts), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

// Check that numbers make sense (liberal bound of 10ns - 30sec)
constexpr uint64_t tenNs = 10UL;
Expand All @@ -57,19 +57,19 @@ TEST(LlvmLibcSchedRRGetIntervalTest, SmokeTest) {

// Null timespec
ASSERT_EQ(LIBC_NAMESPACE::sched_rr_get_interval(0, nullptr), -1);
ASSERT_EQ(libc_errno, EFAULT);
ASSERT_ERRNO_EQ(EFAULT);
libc_errno = 0;

// Negative pid
ASSERT_EQ(LIBC_NAMESPACE::sched_rr_get_interval(-1, &ts), -1);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
}

// Negative tests don't have SCHED_RR set
SetSched(SCHED_OTHER);
ASSERT_EQ(LIBC_NAMESPACE::sched_rr_get_interval(0, &ts), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
libc_errno = 0;

// TODO: Missing unkown pid -> ESRCH. This is read only so safe to try a few
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/sched/yield_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,5 +15,5 @@ TEST(LlvmLibcSchedYieldTest, SmokeTest) {
// sched_yield() always succeeds, just do a basic test that errno/ret are
// properly 0.
ASSERT_EQ(LIBC_NAMESPACE::sched_yield(), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
6 changes: 3 additions & 3 deletions libc/test/src/stdio/fgets_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,7 +48,7 @@ TEST(LlvmLibcFgetsTest, WriteAndReadCharacters) {
output = LIBC_NAMESPACE::fgets(buff, 1, file);
ASSERT_TRUE(output == buff);
ASSERT_EQ(buff[0], '\0');
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

// If we request less than 1 byte, it should do nothing and return nullptr.
// This is also implementation defined.
Expand Down Expand Up @@ -76,13 +76,13 @@ TEST(LlvmLibcFgetsTest, WriteAndReadCharacters) {
// fails to read anything.
ASSERT_NE(LIBC_NAMESPACE::feof(file), 0);
ASSERT_EQ(LIBC_NAMESPACE::ferror(file), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

// Reading more should be an EOF, but not an error.
output = LIBC_NAMESPACE::fgets(buff, 8, file);
ASSERT_TRUE(output == nullptr);
ASSERT_NE(LIBC_NAMESPACE::feof(file), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_EQ(0, LIBC_NAMESPACE::fclose(file));
}
6 changes: 3 additions & 3 deletions libc/test/src/stdio/fileop_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -121,16 +121,16 @@ TEST(LlvmLibcFILETest, SimpleFileOperations) {

// libc_errno = 0;
// ASSERT_NE(LIBC_NAMESPACE::fseek(file, 0, SEEK_SET), 0);
// EXPECT_NE(libc_errno, 0);
// ASSERT_ERRNO_FAILURE();

// libc_errno = 0;
// ASSERT_NE(LIBC_NAMESPACE::fclose(file), 0);
// EXPECT_NE(libc_errno, 0);
// ASSERT_ERRNO_FAILURE();

// libc_errno = 0;
// ASSERT_EQ(LIBC_NAMESPACE::fopen("INVALID FILE NAME", "r"),
// static_cast<FILE *>(nullptr));
// EXPECT_NE(libc_errno, 0);
// ASSERT_ERRNO_FAILURE();
}

TEST(LlvmLibcFILETest, FFlush) {
Expand Down
6 changes: 3 additions & 3 deletions libc/test/src/stdio/fopencookie_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -114,7 +114,7 @@ TEST(LlvmLibcFOpenCookie, ReadOnlyCookieTest) {
// Should be an error to write.
ASSERT_EQ(size_t(0), LIBC_NAMESPACE::fwrite(CONTENT, 1, sizeof(CONTENT), f));
ASSERT_NE(LIBC_NAMESPACE::ferror(f), 0);
ASSERT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;

LIBC_NAMESPACE::clearerr(f);
Expand Down Expand Up @@ -148,7 +148,7 @@ TEST(LlvmLibcFOpenCookie, WriteOnlyCookieTest) {
ASSERT_EQ(size_t(0),
LIBC_NAMESPACE::fread(read_data, 1, sizeof(WRITE_DATA), f));
ASSERT_NE(LIBC_NAMESPACE::ferror(f), 0);
ASSERT_EQ(libc_errno, EBADF);
ASSERT_ERRNO_EQ(EBADF);
libc_errno = 0;

LIBC_NAMESPACE::clearerr(f);
Expand Down Expand Up @@ -177,7 +177,7 @@ TEST(LlvmLibcFOpenCookie, AppendOnlyCookieTest) {
// This is not a readable file.
ASSERT_EQ(LIBC_NAMESPACE::fread(read_data, 1, READ_SIZE, f), size_t(0));
ASSERT_NE(LIBC_NAMESPACE::ferror(f), 0);
EXPECT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;

LIBC_NAMESPACE::clearerr(f);
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/stdio/remove_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ TEST(LlvmLibcRemoveTest, CreateAndRemoveFile) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/remove.test.file";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/stdio/setvbuf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -100,7 +100,7 @@ TEST(LlvmLibcSetbufTest, InvalidBufferMode) {
char buf[BUFSIZ];
ASSERT_NE(LIBC_NAMESPACE::setvbuf(f, buf, _IOFBF + _IOLBF + _IONBF, BUFSIZ),
0);
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);

libc_errno = 0;
ASSERT_EQ(0, LIBC_NAMESPACE::fclose(f));
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/stdio/unlocked_fileop_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -36,7 +36,7 @@ TEST(LlvmLibcFILETest, UnlockedReadAndWrite) {
ASSERT_EQ(size_t(0),
LIBC_NAMESPACE::fread_unlocked(data, 1, sizeof(READ_SIZE), f));
ASSERT_NE(LIBC_NAMESPACE::ferror_unlocked(f), 0);
ASSERT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;

LIBC_NAMESPACE::clearerr_unlocked(f);
Expand All @@ -57,7 +57,7 @@ TEST(LlvmLibcFILETest, UnlockedReadAndWrite) {
ASSERT_EQ(size_t(0),
LIBC_NAMESPACE::fwrite_unlocked(CONTENT, 1, sizeof(CONTENT), f));
ASSERT_NE(LIBC_NAMESPACE::ferror_unlocked(f), 0);
ASSERT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;

LIBC_NAMESPACE::clearerr_unlocked(f);
Expand Down
106 changes: 53 additions & 53 deletions libc/test/src/stdlib/StrtolTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,7 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
const char *ten = "10";
libc_errno = 0;
ASSERT_EQ(func(ten, nullptr, -1), ReturnT(0));
ASSERT_EQ(libc_errno, EINVAL);
ASSERT_ERRNO_EQ(EINVAL);
}

void CleanBaseTenDecode(FunctionT func) {
Expand All @@ -47,23 +47,23 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
const char *ten = "10";
libc_errno = 0;
ASSERT_EQ(func(ten, &str_end, 10), ReturnT(10));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - ten, ptrdiff_t(2));

libc_errno = 0;
ASSERT_EQ(func(ten, nullptr, 10), ReturnT(10));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

const char *hundred = "100";
libc_errno = 0;
ASSERT_EQ(func(hundred, &str_end, 10), ReturnT(100));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - hundred, ptrdiff_t(3));

const char *big_number = "1234567890";
libc_errno = 0;
ASSERT_EQ(func(big_number, &str_end, 10), ReturnT(1234567890));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - big_number, ptrdiff_t(10));

// This number is larger than 2^32, meaning that if long is only 32 bits
Expand All @@ -72,38 +72,38 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
libc_errno = 0;
if constexpr (sizeof(ReturnT) < 8) {
ASSERT_EQ(func(bigger_number, &str_end, 10), T_MAX);
ASSERT_EQ(libc_errno, ERANGE);
ASSERT_ERRNO_EQ(ERANGE);
} else {
ASSERT_EQ(func(bigger_number, &str_end, 10), ReturnT(12345678900));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
EXPECT_EQ(str_end - bigger_number, ptrdiff_t(11));

const char *too_big_number = "123456789012345678901";
libc_errno = 0;
ASSERT_EQ(func(too_big_number, &str_end, 10), T_MAX);
ASSERT_EQ(libc_errno, ERANGE);
ASSERT_ERRNO_EQ(ERANGE);
EXPECT_EQ(str_end - too_big_number, ptrdiff_t(21));

const char *long_number_range_test =
"10000000000000000000000000000000000000000000000000";
libc_errno = 0;
ASSERT_EQ(func(long_number_range_test, &str_end, 10), T_MAX);
ASSERT_EQ(libc_errno, ERANGE);
ASSERT_ERRNO_EQ(ERANGE);
EXPECT_EQ(str_end - long_number_range_test, ptrdiff_t(50));

// 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_errno = 0;
ASSERT_EQ(func(negative, &str_end, 10), ReturnT(-100));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - negative, ptrdiff_t(4));

const char *big_negative_number = "-1234567890";
libc_errno = 0;
ASSERT_EQ(func(big_negative_number, &str_end, 10), ReturnT(-1234567890));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - big_negative_number, ptrdiff_t(11));

const char *too_big_negative_number = "-123456789012345678901";
Expand All @@ -117,7 +117,7 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
// Note that 0 is not on that list.
ASSERT_EQ(func(too_big_negative_number, &str_end, 10),
(is_signed_v<ReturnT> ? T_MIN : T_MAX));
ASSERT_EQ(libc_errno, ERANGE);
ASSERT_ERRNO_EQ(ERANGE);
EXPECT_EQ(str_end - too_big_negative_number, ptrdiff_t(22));
}

Expand All @@ -127,73 +127,73 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
const char *spaces_before = " 10";
libc_errno = 0;
ASSERT_EQ(func(spaces_before, &str_end, 10), ReturnT(10));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - spaces_before, ptrdiff_t(7));

const char *spaces_after = "10 ";
libc_errno = 0;
ASSERT_EQ(func(spaces_after, &str_end, 10), ReturnT(10));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - spaces_after, ptrdiff_t(2));

const char *word_before = "word10";
libc_errno = 0;
ASSERT_EQ(func(word_before, &str_end, 10), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - word_before, ptrdiff_t(0));

const char *word_after = "10word";
libc_errno = 0;
ASSERT_EQ(func(word_after, &str_end, 10), ReturnT(10));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - word_after, ptrdiff_t(2));

const char *two_numbers = "10 999";
libc_errno = 0;
ASSERT_EQ(func(two_numbers, &str_end, 10), ReturnT(10));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - two_numbers, ptrdiff_t(2));

const char *two_signs = "--10 999";
libc_errno = 0;
ASSERT_EQ(func(two_signs, &str_end, 10), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - two_signs, ptrdiff_t(0));

const char *sign_before = "+2=4";
libc_errno = 0;
ASSERT_EQ(func(sign_before, &str_end, 10), ReturnT(2));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - sign_before, ptrdiff_t(2));

const char *sign_after = "2+2=4";
libc_errno = 0;
ASSERT_EQ(func(sign_after, &str_end, 10), ReturnT(2));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - sign_after, ptrdiff_t(1));

const char *tab_before = "\t10";
libc_errno = 0;
ASSERT_EQ(func(tab_before, &str_end, 10), ReturnT(10));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - tab_before, ptrdiff_t(3));

const char *all_together = "\t -12345and+67890";
libc_errno = 0;
ASSERT_EQ(func(all_together, &str_end, 10), ReturnT(-12345));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - all_together, ptrdiff_t(9));

const char *just_spaces = " ";
libc_errno = 0;
ASSERT_EQ(func(just_spaces, &str_end, 10), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_spaces, ptrdiff_t(0));

const char *just_space_and_sign = " +";
libc_errno = 0;
ASSERT_EQ(func(just_space_and_sign, &str_end, 10), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_space_and_sign, ptrdiff_t(0));
}

Expand All @@ -212,11 +212,11 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(first_digit));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
} else {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
}
}
Expand All @@ -231,16 +231,16 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
ASSERT_EQ(
func(small_string, nullptr, base),
static_cast<ReturnT>(second_digit + (first_digit * base)));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
} else if (first_digit < base) {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(first_digit));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
} else {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
}
}
Expand All @@ -261,13 +261,13 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
static_cast<ReturnT>(third_digit +
(second_digit * base) +
(first_digit * base * base)));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
} else if (first_digit < base && second_digit < base) {
libc_errno = 0;
ASSERT_EQ(
func(small_string, nullptr, base),
static_cast<ReturnT>(second_digit + (first_digit * base)));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
} else if (first_digit < base) {
// if the base is 16 there is a special case for the prefix 0X.
// The number is treated as a one digit hexadecimal.
Expand All @@ -276,22 +276,22 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(third_digit));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
} else {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
} else {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base),
static_cast<ReturnT>(first_digit));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
} else {
libc_errno = 0;
ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
}
}
Expand All @@ -305,19 +305,19 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
const char *no_prefix = "123abc";
libc_errno = 0;
ASSERT_EQ(func(no_prefix, &str_end, 16), ReturnT(0x123abc));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - no_prefix, ptrdiff_t(6));

const char *yes_prefix = "0x456def";
libc_errno = 0;
ASSERT_EQ(func(yes_prefix, &str_end, 16), ReturnT(0x456def));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - yes_prefix, ptrdiff_t(8));

const char *letter_after_prefix = "0xabc123";
libc_errno = 0;
ASSERT_EQ(func(letter_after_prefix, &str_end, 16), ReturnT(0xabc123));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - letter_after_prefix, ptrdiff_t(8));

// These tests check what happens when the number passed is exactly the max
Expand Down Expand Up @@ -350,14 +350,14 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
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);
ASSERT_ERRNO_SUCCESS();
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);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - negative_max_31_bit_value, ptrdiff_t(11));

// Max size for unsigned 64 bit numbers
Expand Down Expand Up @@ -391,15 +391,15 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
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);
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_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)));
ASSERT_EQ(libc_errno, sizeof(ReturnT) < 8 ? ERANGE : 0);
ASSERT_ERRNO_EQ(sizeof(ReturnT) < 8 ? ERANGE : 0);
EXPECT_EQ(str_end - negative_max_63_bit_value, ptrdiff_t(19));
}

Expand All @@ -409,23 +409,23 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
const char *just_prefix = "0x";
libc_errno = 0;
ASSERT_EQ(func(just_prefix, &str_end, 16), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_prefix, ptrdiff_t(1));

libc_errno = 0;
ASSERT_EQ(func(just_prefix, &str_end, 0), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_prefix, ptrdiff_t(1));

const char *prefix_with_x_after = "0xx";
libc_errno = 0;
ASSERT_EQ(func(prefix_with_x_after, &str_end, 16), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - prefix_with_x_after, ptrdiff_t(1));

libc_errno = 0;
ASSERT_EQ(func(prefix_with_x_after, &str_end, 0), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - prefix_with_x_after, ptrdiff_t(1));
}

Expand All @@ -435,43 +435,43 @@ struct StrtoTest : public LIBC_NAMESPACE::testing::Test {
const char *base_ten = "12345";
libc_errno = 0;
ASSERT_EQ(func(base_ten, &str_end, 0), ReturnT(12345));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_ten, ptrdiff_t(5));

const char *base_sixteen_no_prefix = "123abc";
libc_errno = 0;
ASSERT_EQ(func(base_sixteen_no_prefix, &str_end, 0), ReturnT(123));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_sixteen_no_prefix, ptrdiff_t(3));

const char *base_sixteen_with_prefix = "0x456def";
libc_errno = 0;
ASSERT_EQ(func(base_sixteen_with_prefix, &str_end, 0), ReturnT(0x456def));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_sixteen_with_prefix, ptrdiff_t(8));

const char *base_eight_with_prefix = "012345";
libc_errno = 0;
ASSERT_EQ(func(base_eight_with_prefix, &str_end, 0), ReturnT(012345));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - base_eight_with_prefix, ptrdiff_t(6));

const char *just_zero = "0";
libc_errno = 0;
ASSERT_EQ(func(just_zero, &str_end, 0), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_zero, ptrdiff_t(1));

const char *just_zero_x = "0x";
libc_errno = 0;
ASSERT_EQ(func(just_zero_x, &str_end, 0), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_zero_x, ptrdiff_t(1));

const char *just_zero_eight = "08";
libc_errno = 0;
ASSERT_EQ(func(just_zero_eight, &str_end, 0), ReturnT(0));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_EQ(str_end - just_zero_eight, ptrdiff_t(1));
}
};
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/stdlib/strtof_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,7 +48,7 @@ class LlvmLibcStrToFTest : public LIBC_NAMESPACE::testing::Test,

EXPECT_EQ(str_end - inputString, expectedStrLen);
EXPECT_FP_EQ(result, expected_fp.get_val());
EXPECT_EQ(libc_errno, expectedErrno);
ASSERT_ERRNO_EQ(expectedErrno);
}
};

Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/stdlib/strtold_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -90,7 +90,7 @@ class LlvmLibcStrToLDTest : public LIBC_NAMESPACE::testing::Test {
EXPECT_EQ(actual_fp.is_neg(), expected_fp.is_neg());
EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(libc_errno, expected_errno);
ASSERT_ERRNO_EQ(expected_errno);
}
};

Expand Down
6 changes: 3 additions & 3 deletions libc/test/src/string/strdup_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ TEST(LlvmLibcStrDupTest, EmptyString) {

libc_errno = 0;
char *result = LIBC_NAMESPACE::strdup(empty);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_NE(result, static_cast<char *>(nullptr));
ASSERT_NE(empty, const_cast<const char *>(result));
Expand All @@ -30,7 +30,7 @@ TEST(LlvmLibcStrDupTest, AnyString) {

libc_errno = 0;
char *result = LIBC_NAMESPACE::strdup(abc);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_NE(result, static_cast<char *>(nullptr));
ASSERT_NE(abc, const_cast<const char *>(result));
Expand All @@ -41,7 +41,7 @@ TEST(LlvmLibcStrDupTest, AnyString) {
TEST(LlvmLibcStrDupTest, NullPtr) {
libc_errno = 0;
char *result = LIBC_NAMESPACE::strdup(nullptr);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_EQ(result, static_cast<char *>(nullptr));
}
2 changes: 1 addition & 1 deletion libc/test/src/sys/prctl/linux/prctl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -36,7 +36,7 @@ TEST(LlvmLibcSysPrctlTest, GetTHPDisable) {
// covered in ErrnoSetterMatcher.
libc_errno = 0;
int ret = LIBC_NAMESPACE::prctl(PR_GET_THP_DISABLE, 0, 0, 0, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
// PR_GET_THP_DISABLE return (as the function result) the current
// setting of the "THP disable" flag for the calling thread, which
// is either 1, if the flag is set; or 0, if it is not.
Expand Down
12 changes: 6 additions & 6 deletions libc/test/src/sys/resource/getrlimit_setrlimit_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,10 +33,10 @@ TEST(LlvmLibcResourceLimitsTest, SetNoFileLimit) {

int fd1 = LIBC_NAMESPACE::open(TEST_FILE1, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(fd1, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
int fd2 = LIBC_NAMESPACE::open(TEST_FILE2, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(fd2, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_THAT(LIBC_NAMESPACE::close(fd1), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::close(fd2), Succeeds(0));
Expand All @@ -49,20 +49,20 @@ TEST(LlvmLibcResourceLimitsTest, SetNoFileLimit) {
// One can now only open one of the files successfully.
fd1 = LIBC_NAMESPACE::open(TEST_FILE1, O_RDONLY);
ASSERT_GT(fd1, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
fd2 = LIBC_NAMESPACE::open(TEST_FILE2, O_RDONLY);
ASSERT_LT(fd2, 0);
ASSERT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();

libc_errno = 0;
ASSERT_THAT(LIBC_NAMESPACE::close(fd1), Succeeds(0));

fd2 = LIBC_NAMESPACE::open(TEST_FILE2, O_RDONLY);
ASSERT_GT(fd2, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
fd1 = LIBC_NAMESPACE::open(TEST_FILE1, O_RDONLY);
ASSERT_LT(fd1, 0);
ASSERT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();

libc_errno = 0;
ASSERT_THAT(LIBC_NAMESPACE::close(fd2), Succeeds(0));
Expand Down
8 changes: 4 additions & 4 deletions libc/test/src/sys/sendfile/sendfile_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,24 +39,24 @@ TEST(LlvmLibcSendfileTest, CreateAndTransfer) {

int in_fd = LIBC_NAMESPACE::open(IN_FILE, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(in_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(LIBC_NAMESPACE::write(in_fd, IN_DATA, IN_SIZE), IN_SIZE);
ASSERT_THAT(LIBC_NAMESPACE::close(in_fd), Succeeds(0));

in_fd = LIBC_NAMESPACE::open(IN_FILE, O_RDONLY);
ASSERT_GT(in_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
int out_fd = LIBC_NAMESPACE::open(OUT_FILE, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(out_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ssize_t size = LIBC_NAMESPACE::sendfile(in_fd, out_fd, nullptr, IN_SIZE);
ASSERT_EQ(size, IN_SIZE);
ASSERT_THAT(LIBC_NAMESPACE::close(in_fd), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::close(out_fd), Succeeds(0));

out_fd = LIBC_NAMESPACE::open(OUT_FILE, O_RDONLY);
ASSERT_GT(out_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
char buf[IN_SIZE];
ASSERT_EQ(IN_SIZE, LIBC_NAMESPACE::read(out_fd, buf, IN_SIZE));
ASSERT_EQ(cpp::string_view(buf), cpp::string_view(IN_DATA));
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/sys/socket/linux/bind_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ TEST(LlvmLibcSocketTest, BindLocalSocket) {

int sock = LIBC_NAMESPACE::socket(AF_UNIX, SOCK_DGRAM, 0);
ASSERT_GE(sock, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

struct sockaddr_un my_addr;

Expand All @@ -47,7 +47,7 @@ TEST(LlvmLibcSocketTest, BindLocalSocket) {
sizeof(struct sockaddr_un));

ASSERT_EQ(result, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

LIBC_NAMESPACE::close(sock);

Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/sys/socket/linux/socket_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,7 @@
TEST(LlvmLibcSocketTest, LocalSocket) {
int sock = LIBC_NAMESPACE::socket(AF_UNIX, SOCK_DGRAM, 0);
ASSERT_GE(sock, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

LIBC_NAMESPACE::close(sock);
}
8 changes: 4 additions & 4 deletions libc/test/src/sys/stat/chmod_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,25 +32,25 @@ TEST(LlvmLibcChmodTest, ChangeAndOpen) {

int fd = LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_WRONLY);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(LIBC_NAMESPACE::write(fd, WRITE_DATA, sizeof(WRITE_DATA)),
WRITE_SIZE);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_PATH);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
EXPECT_THAT(LIBC_NAMESPACE::chmod(TEST_FILE, S_IRUSR), Succeeds(0));

// Opening for writing should fail.
EXPECT_EQ(LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_WRONLY), -1);
EXPECT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;
// But opening for reading should succeed.
fd = LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_RDONLY);
EXPECT_GT(fd, 0);
EXPECT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

EXPECT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
EXPECT_THAT(LIBC_NAMESPACE::chmod(TEST_FILE, S_IRWXU), Succeeds(0));
Expand Down
10 changes: 5 additions & 5 deletions libc/test/src/sys/stat/fchmod_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,25 +32,25 @@ TEST(LlvmLibcChmodTest, ChangeAndOpen) {

int fd = LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_WRONLY);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(LIBC_NAMESPACE::write(fd, WRITE_DATA, sizeof(WRITE_DATA)),
WRITE_SIZE);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_WRONLY);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_THAT(LIBC_NAMESPACE::fchmod(fd, S_IRUSR), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

// Opening for writing should fail.
EXPECT_EQ(LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_WRONLY), -1);
EXPECT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;
// But opening for reading should succeed.
fd = LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_RDONLY);
EXPECT_GT(fd, 0);
EXPECT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

EXPECT_THAT(LIBC_NAMESPACE::fchmod(fd, S_IRWXU), Succeeds(0));
EXPECT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
Expand All @@ -59,6 +59,6 @@ TEST(LlvmLibcChmodTest, ChangeAndOpen) {
TEST(LlvmLibcChmodTest, NonExistentFile) {
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::fchmod(-1, S_IRUSR), -1);
ASSERT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;
}
8 changes: 4 additions & 4 deletions libc/test/src/sys/stat/fchmodat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,26 +34,26 @@ TEST(LlvmLibcFchmodatTest, ChangeAndOpen) {

int fd = LIBC_NAMESPACE::open(TEST_FILE, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(LIBC_NAMESPACE::write(fd, WRITE_DATA, sizeof(WRITE_DATA)),
WRITE_SIZE);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

int dirfd = LIBC_NAMESPACE::open(TEST_DIR, O_DIRECTORY);
ASSERT_GT(dirfd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

EXPECT_THAT(LIBC_NAMESPACE::fchmodat(dirfd, TEST_FILE_BASENAME, S_IRUSR, 0),
Succeeds(0));

// Opening for writing should fail.
EXPECT_EQ(LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_WRONLY), -1);
EXPECT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;
// But opening for reading should succeed.
fd = LIBC_NAMESPACE::open(TEST_FILE, O_APPEND | O_RDONLY);
EXPECT_GT(fd, 0);
EXPECT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

EXPECT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
EXPECT_THAT(LIBC_NAMESPACE::fchmodat(dirfd, TEST_FILE_BASENAME, S_IRWXU, 0),
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/sys/stat/fstat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ TEST(LlvmLibcFStatTest, CreatAndReadMode) {

int fd = LIBC_NAMESPACE::open(TEST_FILE, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

struct stat statbuf;
ASSERT_THAT(LIBC_NAMESPACE::fstat(fd, &statbuf), Succeeds(0));
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/sys/stat/lstat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ TEST(LlvmLibcLStatTest, CreatAndReadMode) {

int fd = LIBC_NAMESPACE::open(TEST_FILE, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

struct stat statbuf;
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/sys/stat/stat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ TEST(LlvmLibcStatTest, CreatAndReadMode) {

int fd = LIBC_NAMESPACE::open(TEST_FILE, O_CREAT | O_WRONLY, S_IRWXU);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

struct stat statbuf;
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/termios/termios_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,7 +48,7 @@ TEST(LlvmLibcTermiosTest, GetAttrSmokeTest) {
int fd = LIBC_NAMESPACE::open("/dev/tty", O_RDONLY);
if (fd < 0)
return; // When /dev/tty is not available, no point continuing.
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::tcgetattr(fd, &t), Succeeds(0));
ASSERT_EQ(LIBC_NAMESPACE::close(fd), 0);
}
Expand All @@ -58,7 +58,7 @@ TEST(LlvmLibcTermiosTest, TcGetSidSmokeTest) {
int fd = LIBC_NAMESPACE::open("/dev/tty", O_RDONLY);
if (fd < 0)
return; // When /dev/tty is not available, no point continuing.
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(LIBC_NAMESPACE::tcgetsid(fd), pid_t(0));
ASSERT_EQ(LIBC_NAMESPACE::close(fd), 0);
}
4 changes: 2 additions & 2 deletions libc/test/src/time/gmtime_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,15 +26,15 @@ TEST(LlvmLibcGmTime, OutOfRange) {
TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR);
struct tm *tm_data = LIBC_NAMESPACE::gmtime(&seconds);
EXPECT_TRUE(tm_data == nullptr);
EXPECT_EQ(libc_errno, EOVERFLOW);
ASSERT_ERRNO_EQ(EOVERFLOW);

libc_errno = 0;
seconds = INT_MIN * static_cast<int64_t>(
TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR) -
1;
tm_data = LIBC_NAMESPACE::gmtime(&seconds);
EXPECT_TRUE(tm_data == nullptr);
EXPECT_EQ(libc_errno, EOVERFLOW);
ASSERT_ERRNO_EQ(EOVERFLOW);
}

TEST(LlvmLibcGmTime, InvalidSeconds) {
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/time/nanosleep_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,6 @@ TEST(LlvmLibcNanosleep, SmokeTest) {
struct timespec tim = {1, 500};
struct timespec tim2 = {0, 0};
int ret = LIBC_NAMESPACE::nanosleep(&tim, &tim2);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(ret, 0);
}
16 changes: 8 additions & 8 deletions libc/test/src/unistd/access_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,29 +24,29 @@ TEST(LlvmLibcAccessTest, CreateAndTest) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/access.test";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

ASSERT_EQ(LIBC_NAMESPACE::access(TEST_FILE, F_OK), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(LIBC_NAMESPACE::access(TEST_FILE, X_OK | W_OK | R_OK), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::unlink(TEST_FILE), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IXUSR);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
ASSERT_EQ(LIBC_NAMESPACE::access(TEST_FILE, F_OK), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(LIBC_NAMESPACE::access(TEST_FILE, X_OK), 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(LIBC_NAMESPACE::access(TEST_FILE, R_OK), -1);
ASSERT_EQ(libc_errno, EACCES);
ASSERT_ERRNO_EQ(EACCES);
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::access(TEST_FILE, W_OK), -1);
ASSERT_EQ(libc_errno, EACCES);
ASSERT_ERRNO_EQ(EACCES);
libc_errno = 0;
ASSERT_THAT(LIBC_NAMESPACE::unlink(TEST_FILE), Succeeds(0));
}
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/chdir_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,13 +28,13 @@ TEST(LlvmLibcChdirTest, ChangeAndOpen) {

int fd = LIBC_NAMESPACE::open(TEST_FILE, O_PATH);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

ASSERT_THAT(LIBC_NAMESPACE::chdir(TEST_DIR), Succeeds(0));
fd = LIBC_NAMESPACE::open(TEST_FILE_BASE, O_PATH);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
}

Expand Down
8 changes: 4 additions & 4 deletions libc/test/src/unistd/dup2_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,10 +24,10 @@ TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/dup2.test";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
int dupfd = LIBC_NAMESPACE::dup2(fd, DUPFD);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(dupfd, DUPFD);

// Write something via the dup
Expand All @@ -39,10 +39,10 @@ TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {

// Reopen the file for reading and create a dup.
fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
dupfd = LIBC_NAMESPACE::dup2(fd, DUPFD);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(dupfd, DUPFD);

// Read the file content via the dup.
Expand Down
8 changes: 4 additions & 4 deletions libc/test/src/unistd/dup3_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,10 +30,10 @@ TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/dup3.test";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
int dupfd = LIBC_NAMESPACE::dup3(fd, DUPFD, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(dupfd, DUPFD);

// Write something via the dup
Expand All @@ -45,10 +45,10 @@ TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {

// Reopen the file for reading and create a dup.
fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
dupfd = LIBC_NAMESPACE::dup3(fd, DUPFD, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(dupfd, DUPFD);

// Read the file content via the dup.
Expand Down
8 changes: 4 additions & 4 deletions libc/test/src/unistd/dup_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,10 +23,10 @@ TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/dup.test";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
int dupfd = LIBC_NAMESPACE::dup(fd);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(dupfd, 0);

// Write something via the dup
Expand All @@ -38,10 +38,10 @@ TEST(LlvmLibcdupTest, ReadAndWriteViaDup) {

// Reopen the file for reading and create a dup.
fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
dupfd = LIBC_NAMESPACE::dup(fd);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(dupfd, 0);

// Read the file content via the dup.
Expand Down
8 changes: 4 additions & 4 deletions libc/test/src/unistd/fchdir_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,16 +28,16 @@ TEST(LlvmLibcChdirTest, ChangeAndOpen) {

int dir_fd = LIBC_NAMESPACE::open(TEST_DIR, O_DIRECTORY);
ASSERT_GT(dir_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
int file_fd = LIBC_NAMESPACE::open(TEST_FILE, O_PATH);
ASSERT_GT(file_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(file_fd), Succeeds(0));

ASSERT_THAT(LIBC_NAMESPACE::fchdir(dir_fd), Succeeds(0));
file_fd = LIBC_NAMESPACE::open(TEST_FILE_BASE, O_PATH);
ASSERT_GT(file_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(file_fd), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::close(dir_fd), Succeeds(0));
}
Expand All @@ -46,6 +46,6 @@ TEST(LlvmLibcChdirTest, ChangeToNonExistentDir) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Fails;
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::fchdir(0), -1);
ASSERT_NE(libc_errno, 0);
ASSERT_ERRNO_FAILURE();
libc_errno = 0;
}
8 changes: 4 additions & 4 deletions libc/test/src/unistd/ftruncate_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,14 +35,14 @@ TEST(LlvmLibcFtruncateTest, CreateAndTruncate) {
// 4. Try to read more than 1 byte and fail.
libc_errno = 0;
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_EQ(ssize_t(WRITE_SIZE),
LIBC_NAMESPACE::write(fd, WRITE_DATA, WRITE_SIZE));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_EQ(ssize_t(WRITE_SIZE), LIBC_NAMESPACE::read(fd, buf, WRITE_SIZE));
ASSERT_EQ(cpp::string_view(buf), cpp::string_view(WRITE_DATA));
Expand All @@ -52,12 +52,12 @@ TEST(LlvmLibcFtruncateTest, CreateAndTruncate) {
// writing.
fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY);
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::ftruncate(fd, off_t(1)), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_EQ(ssize_t(1), LIBC_NAMESPACE::read(fd, buf, WRITE_SIZE));
ASSERT_EQ(buf[0], WRITE_DATA[0]);
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/isatty_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,7 @@ TEST(LlvmLibcIsATTYTest, DevTTYTest) {
libc_errno = 0;
int fd = LIBC_NAMESPACE::open(TTY_FILE, O_RDONLY);
if (fd > 0) {
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
EXPECT_THAT(LIBC_NAMESPACE::isatty(fd), Succeeds(1));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
}
Expand All @@ -53,7 +53,7 @@ TEST(LlvmLibcIsATTYTest, FileTest) {
constexpr const char *TEST_FILE = "testdata/isatty.test";
libc_errno = 0;
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
EXPECT_THAT(LIBC_NAMESPACE::isatty(fd), Fails(ENOTTY, 0));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/link_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,14 +28,14 @@ TEST(LlvmLibcLinkTest, CreateAndUnlink) {
// 4. Cleanup the file and its link.
libc_errno = 0;
int write_fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(write_fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(write_fd), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::link(TEST_FILE, TEST_FILE_LINK), Succeeds(0));

int link_fd = LIBC_NAMESPACE::open(TEST_FILE_LINK, O_PATH);
ASSERT_GT(link_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(link_fd), Succeeds(0));

ASSERT_THAT(LIBC_NAMESPACE::unlink(TEST_FILE), Succeeds(0));
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/linkat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ TEST(LlvmLibcLinkatTest, CreateAndUnlink) {
libc_errno = 0;
int write_fd =
LIBC_NAMESPACE::open(TEST_FILE_PATH, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(write_fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(write_fd), Succeeds(0));

Expand All @@ -43,7 +43,7 @@ TEST(LlvmLibcLinkatTest, CreateAndUnlink) {

int link_fd = LIBC_NAMESPACE::open(TEST_FILE_LINK_PATH, O_PATH);
ASSERT_GT(link_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(link_fd), Succeeds(0));

ASSERT_THAT(LIBC_NAMESPACE::unlink(TEST_FILE_PATH), Succeeds(0));
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/lseek_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,7 @@ TEST(LlvmLibcUniStd, LseekTest) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/lseek.test";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
constexpr const char LSEEK_TEST[] = "lseek test";
constexpr int LSEEK_TEST_SIZE = sizeof(LSEEK_TEST) - 1;
Expand Down Expand Up @@ -54,7 +54,7 @@ TEST(LlvmLibcUniStd, LseekFailsTest) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/lseek.test";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
EXPECT_THAT(LIBC_NAMESPACE::lseek(fd, -1, SEEK_CUR), Fails(EINVAL));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
Expand Down
6 changes: 3 additions & 3 deletions libc/test/src/unistd/pread_pwrite_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,23 +34,23 @@ TEST(LlvmLibcUniStd, PWriteAndPReadBackTest) {

constexpr const char *TEST_FILE = "testdata/pread_pwrite.test";
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::write(fd, HELLO, HELLO_SIZE),
Succeeds(HELLO_SIZE));
ASSERT_THAT(LIBC_NAMESPACE::fsync(fd), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::pwrite(fd, HELLO, HELLO_SIZE, OFFSET),
Succeeds(HELLO_SIZE));
ASSERT_THAT(LIBC_NAMESPACE::fsync(fd), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
char read_buf[OFFSET_TEXT_SIZE];
ASSERT_THAT(LIBC_NAMESPACE::pread(fd, read_buf, HELLO_SIZE, OFFSET),
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/read_write_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,7 +21,7 @@ TEST(LlvmLibcUniStd, WriteAndReadBackTest) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "__unistd_read_write.test";
int write_fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(write_fd, 0);
constexpr const char HELLO[] = "hello";
constexpr int HELLO_SIZE = sizeof(HELLO);
Expand All @@ -31,7 +31,7 @@ TEST(LlvmLibcUniStd, WriteAndReadBackTest) {
ASSERT_THAT(LIBC_NAMESPACE::close(write_fd), Succeeds(0));

int read_fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(read_fd, 0);
char read_buf[10];
ASSERT_THAT(LIBC_NAMESPACE::read(read_fd, read_buf, HELLO_SIZE),
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/unistd/readlink_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ TEST(LlvmLibcReadlinkTest, CreateAndUnlink) {

char buf[sizeof(LINK_VAL)];
ssize_t len = LIBC_NAMESPACE::readlink(LINK, buf, sizeof(buf));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(cpp::string_view(buf, len), cpp::string_view(LINK_VAL));

ASSERT_THAT(LIBC_NAMESPACE::unlink(LINK), Succeeds(0));
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/unistd/readlinkat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ TEST(LlvmLibcReadlinkatTest, CreateAndUnlink) {

char buf[sizeof(LINK_VAL)];
ssize_t len = LIBC_NAMESPACE::readlinkat(AT_FDCWD, LINK, buf, sizeof(buf));
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_EQ(cpp::string_view(buf, len), cpp::string_view(LINK_VAL));

ASSERT_THAT(LIBC_NAMESPACE::unlink(LINK), Succeeds(0));
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/symlink_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,7 +29,7 @@ TEST(LlvmLibcSymlinkTest, CreateAndUnlink) {
// 4. Cleanup the file and its symlink.
libc_errno = 0;
int write_fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(write_fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(write_fd), Succeeds(0));

Expand All @@ -38,7 +38,7 @@ TEST(LlvmLibcSymlinkTest, CreateAndUnlink) {

int symlink_fd = LIBC_NAMESPACE::open(TEST_FILE_LINK, O_PATH);
ASSERT_GT(symlink_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(symlink_fd), Succeeds(0));

ASSERT_THAT(LIBC_NAMESPACE::unlink(TEST_FILE), Succeeds(0));
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/unistd/symlinkat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ TEST(LlvmLibcSymlinkatTest, CreateAndUnlink) {
libc_errno = 0;
int write_fd =
LIBC_NAMESPACE::open(TEST_FILE_PATH, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(write_fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(write_fd), Succeeds(0));

Expand All @@ -42,7 +42,7 @@ TEST(LlvmLibcSymlinkatTest, CreateAndUnlink) {

int link_fd = LIBC_NAMESPACE::open(TEST_FILE_LINK_PATH, O_PATH);
ASSERT_GT(link_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_THAT(LIBC_NAMESPACE::close(link_fd), Succeeds(0));

ASSERT_THAT(LIBC_NAMESPACE::close(dir_fd), Succeeds(0));
Expand Down
32 changes: 16 additions & 16 deletions libc/test/src/unistd/syscall_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ TEST(LlvmLibcSyscallTest, TrivialCall) {
libc_errno = 0;

ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_gettid), 0l);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}

TEST(LlvmLibcSyscallTest, SymlinkCreateDestroy) {
Expand All @@ -45,7 +45,7 @@ TEST(LlvmLibcSyscallTest, SymlinkCreateDestroy) {
#else
#error "symlink and symlinkat syscalls not available."
#endif
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

char buf[sizeof(LINK_VAL)];

Expand All @@ -56,7 +56,7 @@ TEST(LlvmLibcSyscallTest, SymlinkCreateDestroy) {
LIBC_NAMESPACE::syscall(SYS_readlinkat, AT_FDCWD, LINK, buf, sizeof(buf)),
0l);
#endif
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

#ifdef SYS_unlink
ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_unlink, LINK), 0l);
Expand All @@ -65,7 +65,7 @@ TEST(LlvmLibcSyscallTest, SymlinkCreateDestroy) {
#else
#error "unlink and unlinkat syscalls not available."
#endif
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}

TEST(LlvmLibcSyscallTest, FileReadWrite) {
Expand All @@ -84,17 +84,17 @@ TEST(LlvmLibcSyscallTest, FileReadWrite) {
#error "open and openat syscalls not available."
#endif
ASSERT_GT(fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_pwrite64, fd, HELLO, HELLO_SIZE, 0),
0l);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_fsync, fd), 0l);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_close, fd), 0l);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}

TEST(LlvmLibcSyscallTest, FileLinkCreateDestroy) {
Expand All @@ -121,10 +121,10 @@ TEST(LlvmLibcSyscallTest, FileLinkCreateDestroy) {
#error "open and openat syscalls not available."
#endif
ASSERT_GT(write_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_close, write_fd), 0l);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

#ifdef SYS_open
int dir_fd = LIBC_NAMESPACE::syscall(SYS_open, TEST_DIR, O_DIRECTORY, 0);
Expand All @@ -135,12 +135,12 @@ TEST(LlvmLibcSyscallTest, FileLinkCreateDestroy) {
#error "open and openat syscalls not available."
#endif
ASSERT_GT(dir_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_linkat, dir_fd, TEST_FILE, dir_fd,
TEST_FILE_LINK, 0),
0l);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
#ifdef SYS_open
int link_fd =
LIBC_NAMESPACE::syscall(SYS_open, TEST_FILE_LINK_PATH, O_PATH, 0);
Expand All @@ -151,7 +151,7 @@ TEST(LlvmLibcSyscallTest, FileLinkCreateDestroy) {
#error "open and openat syscalls not available."
#endif
ASSERT_GT(link_fd, 0);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

#ifdef SYS_unlink
ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_unlink, TEST_FILE_PATH), 0l);
Expand All @@ -161,7 +161,7 @@ TEST(LlvmLibcSyscallTest, FileLinkCreateDestroy) {
#else
#error "unlink and unlinkat syscalls not available."
#endif
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

#ifdef SYS_unlink
ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_unlink, TEST_FILE_LINK_PATH), 0l);
Expand All @@ -172,8 +172,8 @@ TEST(LlvmLibcSyscallTest, FileLinkCreateDestroy) {
#else
#error "unlink and unlinkat syscalls not available."
#endif
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();

ASSERT_GE(LIBC_NAMESPACE::syscall(SYS_close, dir_fd), 0l);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
}
6 changes: 3 additions & 3 deletions libc/test/src/unistd/truncate_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,14 +35,14 @@ TEST(LlvmLibcTruncateTest, CreateAndTruncate) {
// 4. Try to read more than 1 byte and fail.
libc_errno = 0;
int fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_EQ(ssize_t(WRITE_SIZE),
LIBC_NAMESPACE::write(fd, WRITE_DATA, WRITE_SIZE));
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_EQ(ssize_t(WRITE_SIZE), LIBC_NAMESPACE::read(fd, buf, WRITE_SIZE));
ASSERT_EQ(cpp::string_view(buf), cpp::string_view(WRITE_DATA));
Expand All @@ -51,7 +51,7 @@ TEST(LlvmLibcTruncateTest, CreateAndTruncate) {
ASSERT_THAT(LIBC_NAMESPACE::truncate(TEST_FILE, off_t(1)), Succeeds(0));

fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(fd, 0);
ASSERT_EQ(ssize_t(1), LIBC_NAMESPACE::read(fd, buf, WRITE_SIZE));
ASSERT_EQ(buf[0], WRITE_DATA[0]);
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/unistd/unlink_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,7 @@ TEST(LlvmLibcUnlinkTest, CreateAndUnlink) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/unlink.test";
int write_fd = LIBC_NAMESPACE::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(write_fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(write_fd), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::unlink(TEST_FILE), Succeeds(0));
Expand Down
6 changes: 3 additions & 3 deletions libc/test/src/unistd/unlinkat_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,11 +21,11 @@ TEST(LlvmLibcUnlinkatTest, CreateAndDeleteTest) {
constexpr const char *TEST_DIR = "testdata";
constexpr const char *TEST_FILE = "openat.test";
int dir_fd = LIBC_NAMESPACE::open(TEST_DIR, O_DIRECTORY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(dir_fd, 0);
int write_fd =
LIBC_NAMESPACE::openat(dir_fd, TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(write_fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(write_fd), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::unlinkat(dir_fd, TEST_FILE, 0), Succeeds(0));
Expand All @@ -35,7 +35,7 @@ TEST(LlvmLibcUnlinkatTest, CreateAndDeleteTest) {
TEST(LlvmLibcUnlinkatTest, UnlinkatNonExistentFile) {
constexpr const char *TEST_DIR = "testdata";
int dir_fd = LIBC_NAMESPACE::open(TEST_DIR, O_DIRECTORY);
ASSERT_EQ(libc_errno, 0);
ASSERT_ERRNO_SUCCESS();
ASSERT_GT(dir_fd, 0);
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Fails;
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
Expand Down