Skip to content

Commit 73874f7

Browse files
gchateletgchatelet
authored
[libc][NFC] Use specific ASSERT macros to test errno (#79573)
This patch provides specific test macros to deal with `errno`. This will help abstract away the differences between unit test and integration/hermetic tests in #79319. In one case we use `libc_errno` which is a struct, in the other case we deal directly with `errno`.
1 parent 035f33b commit 73874f7

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

57 files changed

+274
-253
lines changed

‎libc/test/IntegrationTest/test.h

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -45,10 +45,17 @@
4545
LIBC_NAMESPACE::quick_exit(127); \
4646
}
4747

48+
////////////////////////////////////////////////////////////////////////////////
49+
// Boolean checks are handled as comparison to the true / false values.
50+
4851
#define EXPECT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, false)
4952
#define ASSERT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, true)
5053
#define EXPECT_FALSE(val) __CHECK_FALSE(__FILE__, __LINE__, val, false)
5154
#define ASSERT_FALSE(val) __CHECK_FALSE(__FILE__, __LINE__, val, true)
55+
56+
////////////////////////////////////////////////////////////////////////////////
57+
// Binary equality / inequality.
58+
5259
#define EXPECT_EQ(val1, val2) \
5360
__CHECK_EQ(__FILE__, __LINE__, (val1), (val2), false)
5461
#define ASSERT_EQ(val1, val2) \
@@ -58,6 +65,13 @@
5865
#define ASSERT_NE(val1, val2) \
5966
__CHECK_NE(__FILE__, __LINE__, (val1), (val2), true)
6067

68+
////////////////////////////////////////////////////////////////////////////////
69+
// Errno checks.
70+
71+
#define ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, static_cast<int>(libc_errno))
72+
#define ASSERT_ERRNO_SUCCESS() ASSERT_EQ(0, static_cast<int>(libc_errno))
73+
#define ASSERT_ERRNO_FAILURE() ASSERT_NE(0, static_cast<int>(libc_errno))
74+
6175
// Integration tests are compiled with -ffreestanding which stops treating
6276
// the main function as a non-overloadable special function. Hence, we use a
6377
// convenience macro which declares it 'extern "C"'.

‎libc/test/UnitTest/LibcTest.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -443,6 +443,13 @@ CString libc_make_test_file_path_func(const char *file_name);
443443
#define EXPECT_STRNE(LHS, RHS) LIBC_TEST_STR_(testStrNe, LHS, RHS, )
444444
#define ASSERT_STRNE(LHS, RHS) LIBC_TEST_STR_(testStrNe, LHS, RHS, return)
445445

446+
////////////////////////////////////////////////////////////////////////////////
447+
// Errno checks.
448+
449+
#define ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, static_cast<int>(libc_errno))
450+
#define ASSERT_ERRNO_SUCCESS() ASSERT_EQ(0, static_cast<int>(libc_errno))
451+
#define ASSERT_ERRNO_FAILURE() ASSERT_NE(0, static_cast<int>(libc_errno))
452+
446453
////////////////////////////////////////////////////////////////////////////////
447454
// Subprocess checks.
448455

‎libc/test/integration/src/pthread/pthread_create_test.cpp

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ static void *successThread(void *Arg) {
4747
pthread_t th = LIBC_NAMESPACE::pthread_self();
4848
auto *thread = reinterpret_cast<LIBC_NAMESPACE::Thread *>(&th);
4949

50-
ASSERT_EQ(libc_errno, 0);
50+
ASSERT_ERRNO_SUCCESS();
5151
ASSERT_TRUE(thread);
5252
ASSERT_TRUE(thread->attrib);
5353

@@ -62,22 +62,22 @@ static void *successThread(void *Arg) {
6262
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_getstack(expec_attrs, &expec_stack,
6363
&expec_stacksize),
6464
0);
65-
ASSERT_EQ(libc_errno, 0);
65+
ASSERT_ERRNO_SUCCESS();
6666

6767
ASSERT_EQ(
6868
LIBC_NAMESPACE::pthread_attr_getstacksize(expec_attrs, &expec_stacksize2),
6969
0);
70-
ASSERT_EQ(libc_errno, 0);
70+
ASSERT_ERRNO_SUCCESS();
7171

7272
ASSERT_EQ(
7373
LIBC_NAMESPACE::pthread_attr_getguardsize(expec_attrs, &expec_guardsize),
7474
0);
75-
ASSERT_EQ(libc_errno, 0);
75+
ASSERT_ERRNO_SUCCESS();
7676

7777
ASSERT_EQ(
7878
LIBC_NAMESPACE::pthread_attr_getdetachstate(expec_attrs, &expec_detached),
7979
0);
80-
ASSERT_EQ(libc_errno, 0);
80+
ASSERT_ERRNO_SUCCESS();
8181

8282
ASSERT_EQ(expec_stacksize, expec_stacksize2);
8383

@@ -125,7 +125,7 @@ static void *successThread(void *Arg) {
125125
// permissions. Maybe we can read from /proc/{self}/map?
126126

127127
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_destroy(expec_attrs), 0);
128-
ASSERT_EQ(libc_errno, 0);
128+
ASSERT_ERRNO_SUCCESS();
129129

130130
// Arg is malloced, so free.
131131
delete th_arg;
@@ -140,34 +140,34 @@ static void run_success_config(int detachstate, size_t guardsize,
140140
pthread_attr_t *attr = &(th_arg->attrs);
141141

142142
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(attr), 0);
143-
ASSERT_EQ(libc_errno, 0);
143+
ASSERT_ERRNO_SUCCESS();
144144

145145
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setdetachstate(attr, detachstate), 0);
146-
ASSERT_EQ(libc_errno, 0);
146+
ASSERT_ERRNO_SUCCESS();
147147

148148
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(attr, guardsize), 0);
149-
ASSERT_EQ(libc_errno, 0);
149+
ASSERT_ERRNO_SUCCESS();
150150

151151
void *Stack = nullptr;
152152
if (customstack) {
153153
Stack = LIBC_NAMESPACE::mmap(nullptr, stacksize, PROT_READ | PROT_WRITE,
154154
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
155155
ASSERT_NE(Stack, MAP_FAILED);
156156
ASSERT_NE(Stack, static_cast<void *>(nullptr));
157-
ASSERT_EQ(libc_errno, 0);
157+
ASSERT_ERRNO_SUCCESS();
158158

159159
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstack(attr, Stack, stacksize), 0);
160-
ASSERT_EQ(libc_errno, 0);
160+
ASSERT_ERRNO_SUCCESS();
161161
} else {
162162
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(attr, stacksize), 0);
163-
ASSERT_EQ(libc_errno, 0);
163+
ASSERT_ERRNO_SUCCESS();
164164
}
165165

166166
void *expec_ret = nullptr;
167167
if (detachstate == PTHREAD_CREATE_JOINABLE) {
168168
ASSERT_EQ(LIBC_NAMESPACE::getrandom(&expec_ret, sizeof(expec_ret), 0),
169169
static_cast<ssize_t>(sizeof(expec_ret)));
170-
ASSERT_EQ(libc_errno, 0);
170+
ASSERT_ERRNO_SUCCESS();
171171
}
172172

173173
th_arg->ret = expec_ret;
@@ -178,17 +178,17 @@ static void run_success_config(int detachstate, size_t guardsize,
178178
ASSERT_EQ(LIBC_NAMESPACE::pthread_create(&tid, attr, successThread,
179179
reinterpret_cast<void *>(th_arg)),
180180
0);
181-
ASSERT_EQ(libc_errno, 0);
181+
ASSERT_ERRNO_SUCCESS();
182182

183183
if (detachstate == PTHREAD_CREATE_JOINABLE) {
184184
void *th_ret;
185185
ASSERT_EQ(LIBC_NAMESPACE::pthread_join(tid, &th_ret), 0);
186-
ASSERT_EQ(libc_errno, 0);
186+
ASSERT_ERRNO_SUCCESS();
187187
ASSERT_EQ(th_ret, expec_ret);
188188

189189
if (customstack) {
190190
ASSERT_EQ(LIBC_NAMESPACE::munmap(Stack, stacksize), 0);
191-
ASSERT_EQ(libc_errno, 0);
191+
ASSERT_ERRNO_SUCCESS();
192192
}
193193
} else {
194194
ASSERT_FALSE(customstack);
@@ -260,23 +260,23 @@ static void create_and_check_failure_thread(pthread_attr_t *attr) {
260260
// was just really larger we failed mmap.
261261
ASSERT_TRUE(result == EINVAL || result == EAGAIN);
262262
// pthread_create should NOT set errno on error
263-
ASSERT_EQ(libc_errno, 0);
263+
ASSERT_ERRNO_SUCCESS();
264264

265265
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_destroy(attr), 0);
266-
ASSERT_EQ(libc_errno, 0);
266+
ASSERT_ERRNO_SUCCESS();
267267
}
268268

269269
static void run_failure_config(size_t guardsize, size_t stacksize) {
270270
pthread_attr_t attr;
271271
guardsize &= -EXEC_PAGESIZE;
272272
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
273-
ASSERT_EQ(libc_errno, 0);
273+
ASSERT_ERRNO_SUCCESS();
274274

275275
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(&attr, guardsize), 0);
276-
ASSERT_EQ(libc_errno, 0);
276+
ASSERT_ERRNO_SUCCESS();
277277

278278
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(&attr, stacksize), 0);
279-
ASSERT_EQ(libc_errno, 0);
279+
ASSERT_ERRNO_SUCCESS();
280280

281281
create_and_check_failure_thread(&attr);
282282
}
@@ -301,32 +301,32 @@ static void run_failure_tests() {
301301

302302
// Stacksize too small.
303303
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
304-
ASSERT_EQ(libc_errno, 0);
304+
ASSERT_ERRNO_SUCCESS();
305305
attr.__stacksize = PTHREAD_STACK_MIN - 16;
306306
create_and_check_failure_thread(&attr);
307307

308308
// Stack misaligned.
309309
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
310-
ASSERT_EQ(libc_errno, 0);
310+
ASSERT_ERRNO_SUCCESS();
311311
attr.__stack = reinterpret_cast<void *>(1);
312312
create_and_check_failure_thread(&attr);
313313

314314
// Stack + stacksize misaligned.
315315
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
316-
ASSERT_EQ(libc_errno, 0);
316+
ASSERT_ERRNO_SUCCESS();
317317
attr.__stacksize = PTHREAD_STACK_MIN + 1;
318318
attr.__stack = reinterpret_cast<void *>(16);
319319
create_and_check_failure_thread(&attr);
320320

321321
// Guardsize misaligned.
322322
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
323-
ASSERT_EQ(libc_errno, 0);
323+
ASSERT_ERRNO_SUCCESS();
324324
attr.__guardsize = EXEC_PAGESIZE / 2;
325325
create_and_check_failure_thread(&attr);
326326

327327
// Detachstate is unknown.
328328
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
329-
ASSERT_EQ(libc_errno, 0);
329+
ASSERT_ERRNO_SUCCESS();
330330
attr.__detachstate = -1;
331331
create_and_check_failure_thread(&attr);
332332
}

‎libc/test/integration/src/pthread/pthread_join_test.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,9 @@ static void nullJoinTest() {
1919
pthread_t Tid;
2020
ASSERT_EQ(LIBC_NAMESPACE::pthread_create(&Tid, nullptr, simpleFunc, nullptr),
2121
0);
22-
ASSERT_EQ(libc_errno, 0);
22+
ASSERT_ERRNO_SUCCESS();
2323
ASSERT_EQ(LIBC_NAMESPACE::pthread_join(Tid, nullptr), 0);
24-
ASSERT_EQ(libc_errno, 0);
24+
ASSERT_ERRNO_SUCCESS();
2525
}
2626

2727
TEST_MAIN() {

‎libc/test/integration/src/unistd/getcwd_test.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ TEST_MAIN(int argc, char **argv, char **envp) {
3030
// Bad size
3131
cwd = LIBC_NAMESPACE::getcwd(buffer, 0);
3232
ASSERT_TRUE(cwd == nullptr);
33-
ASSERT_EQ(libc_errno, EINVAL);
33+
ASSERT_ERRNO_EQ(EINVAL);
3434
libc_errno = 0;
3535

3636
// Insufficient size

‎libc/test/src/dirent/dirent_test.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ TEST(LlvmLibcDirentTest, SimpleOpenAndRead) {
4444
}
4545

4646
// Verify that we don't break out of the above loop in error.
47-
ASSERT_EQ(libc_errno, 0);
47+
ASSERT_ERRNO_SUCCESS();
4848

4949
ASSERT_TRUE(file1 != nullptr);
5050
ASSERT_TRUE(file2 != nullptr);
@@ -58,14 +58,14 @@ TEST(LlvmLibcDirentTest, OpenNonExistentDir) {
5858
libc_errno = 0;
5959
::DIR *dir = LIBC_NAMESPACE::opendir("___xyz123__.non_existent__");
6060
ASSERT_TRUE(dir == nullptr);
61-
ASSERT_EQ(libc_errno, ENOENT);
61+
ASSERT_ERRNO_EQ(ENOENT);
6262
libc_errno = 0;
6363
}
6464

6565
TEST(LlvmLibcDirentTest, OpenFile) {
6666
libc_errno = 0;
6767
::DIR *dir = LIBC_NAMESPACE::opendir("testdata/file1.txt");
6868
ASSERT_TRUE(dir == nullptr);
69-
ASSERT_EQ(libc_errno, ENOTDIR);
69+
ASSERT_ERRNO_EQ(ENOTDIR);
7070
libc_errno = 0;
7171
}

‎libc/test/src/fcntl/creat_test.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,12 +19,12 @@ TEST(LlvmLibcCreatTest, CreatAndOpen) {
1919
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
2020
constexpr const char *TEST_FILE = "testdata/creat.test";
2121
int fd = LIBC_NAMESPACE::creat(TEST_FILE, S_IRWXU);
22-
ASSERT_EQ(libc_errno, 0);
22+
ASSERT_ERRNO_SUCCESS();
2323
ASSERT_GT(fd, 0);
2424
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
2525

2626
fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
27-
ASSERT_EQ(libc_errno, 0);
27+
ASSERT_ERRNO_SUCCESS();
2828
ASSERT_GT(fd, 0);
2929
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
3030

‎libc/test/src/fcntl/openat_test.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,13 +21,13 @@ TEST(LlvmLibcUniStd, OpenAndReadTest) {
2121
constexpr const char *TEST_DIR = "testdata";
2222
constexpr const char *TEST_FILE = "openat.test";
2323
int dir_fd = LIBC_NAMESPACE::open(TEST_DIR, O_DIRECTORY);
24-
ASSERT_EQ(libc_errno, 0);
24+
ASSERT_ERRNO_SUCCESS();
2525
ASSERT_GT(dir_fd, 0);
2626
constexpr const char TEST_MSG[] = "openat test";
2727
constexpr int TEST_MSG_SIZE = sizeof(TEST_MSG) - 1;
2828

2929
int read_fd = LIBC_NAMESPACE::openat(dir_fd, TEST_FILE, O_RDONLY);
30-
ASSERT_EQ(libc_errno, 0);
30+
ASSERT_ERRNO_SUCCESS();
3131
ASSERT_GT(read_fd, 0);
3232
char read_buf[TEST_MSG_SIZE];
3333
ASSERT_THAT(LIBC_NAMESPACE::read(read_fd, read_buf, TEST_MSG_SIZE),

‎libc/test/src/sched/get_priority_test.cpp

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -20,40 +20,40 @@ TEST(LlvmLibcSchedGetPriorityTest, HandleBadPolicyTest) {
2020
int policy = -1;
2121
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
2222
ASSERT_EQ(max_priority, -1);
23-
ASSERT_EQ(libc_errno, EINVAL);
23+
ASSERT_ERRNO_EQ(EINVAL);
2424
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
2525
ASSERT_EQ(min_priority, -1);
26-
ASSERT_EQ(libc_errno, EINVAL);
26+
ASSERT_ERRNO_EQ(EINVAL);
2727
}
2828

2929
{
3030
int policy = 30;
3131
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
3232
ASSERT_EQ(max_priority, -1);
33-
ASSERT_EQ(libc_errno, EINVAL);
33+
ASSERT_ERRNO_EQ(EINVAL);
3434
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
3535
ASSERT_EQ(min_priority, -1);
36-
ASSERT_EQ(libc_errno, EINVAL);
36+
ASSERT_ERRNO_EQ(EINVAL);
3737
}
3838

3939
{
4040
int policy = 80;
4141
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
4242
ASSERT_EQ(max_priority, -1);
43-
ASSERT_EQ(libc_errno, EINVAL);
43+
ASSERT_ERRNO_EQ(EINVAL);
4444
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
4545
ASSERT_EQ(min_priority, -1);
46-
ASSERT_EQ(libc_errno, EINVAL);
46+
ASSERT_ERRNO_EQ(EINVAL);
4747
}
4848

4949
{
5050
int policy = 110;
5151
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
5252
ASSERT_EQ(max_priority, -1);
53-
ASSERT_EQ(libc_errno, EINVAL);
53+
ASSERT_ERRNO_EQ(EINVAL);
5454
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
5555
ASSERT_EQ(min_priority, -1);
56-
ASSERT_EQ(libc_errno, EINVAL);
56+
ASSERT_ERRNO_EQ(EINVAL);
5757
}
5858
}
5959

@@ -68,10 +68,10 @@ TEST(LlvmLibcSchedGetPriorityTest, SmokeTest) {
6868
int policy = SCHED_OTHER;
6969
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
7070
ASSERT_GE(max_priority, 0);
71-
ASSERT_EQ(libc_errno, 0);
71+
ASSERT_ERRNO_SUCCESS();
7272
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
7373
ASSERT_GE(min_priority, 0);
74-
ASSERT_EQ(libc_errno, 0);
74+
ASSERT_ERRNO_SUCCESS();
7575

7676
ASSERT_LE(max_priority, 99);
7777
ASSERT_GE(min_priority, 0);
@@ -82,10 +82,10 @@ TEST(LlvmLibcSchedGetPriorityTest, SmokeTest) {
8282
int policy = SCHED_FIFO;
8383
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
8484
ASSERT_GE(max_priority, 0);
85-
ASSERT_EQ(libc_errno, 0);
85+
ASSERT_ERRNO_SUCCESS();
8686
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
8787
ASSERT_GE(min_priority, 0);
88-
ASSERT_EQ(libc_errno, 0);
88+
ASSERT_ERRNO_SUCCESS();
8989

9090
ASSERT_LE(max_priority, 99);
9191
ASSERT_GE(min_priority, 0);
@@ -96,10 +96,10 @@ TEST(LlvmLibcSchedGetPriorityTest, SmokeTest) {
9696
int policy = SCHED_RR;
9797
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
9898
ASSERT_GE(max_priority, 0);
99-
ASSERT_EQ(libc_errno, 0);
99+
ASSERT_ERRNO_SUCCESS();
100100
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
101101
ASSERT_GE(min_priority, 0);
102-
ASSERT_EQ(libc_errno, 0);
102+
ASSERT_ERRNO_SUCCESS();
103103

104104
ASSERT_LE(max_priority, 99);
105105
ASSERT_GE(min_priority, 0);

0 commit comments

Comments
 (0)