diff --git a/lib/libc/tests/secure/fortify_poll_test.c b/lib/libc/tests/secure/fortify_poll_test.c --- a/lib/libc/tests/secure/fortify_poll_test.c +++ b/lib/libc/tests/secure/fortify_poll_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(poll_before_end); +ATF_TC(poll_before_end); +ATF_TC_HEAD(poll_before_end, tc) +{ +} ATF_TC_BODY(poll_before_end, tc) { #define BUF &__stack.__buf @@ -184,7 +187,10 @@ } -ATF_TC_WITHOUT_HEAD(poll_end); +ATF_TC(poll_end); +ATF_TC_HEAD(poll_end, tc) +{ +} ATF_TC_BODY(poll_end, tc) { #define BUF &__stack.__buf @@ -206,7 +212,10 @@ } -ATF_TC_WITHOUT_HEAD(poll_after_end); +ATF_TC(poll_after_end); +ATF_TC_HEAD(poll_after_end, tc) +{ +} ATF_TC_BODY(poll_after_end, tc) { #define BUF &__stack.__buf @@ -259,7 +268,10 @@ } -ATF_TC_WITHOUT_HEAD(poll_heap_before_end); +ATF_TC(poll_heap_before_end); +ATF_TC_HEAD(poll_heap_before_end, tc) +{ +} ATF_TC_BODY(poll_heap_before_end, tc) { #define BUF __stack.__buf @@ -282,7 +294,10 @@ } -ATF_TC_WITHOUT_HEAD(poll_heap_end); +ATF_TC(poll_heap_end); +ATF_TC_HEAD(poll_heap_end, tc) +{ +} ATF_TC_BODY(poll_heap_end, tc) { #define BUF __stack.__buf @@ -305,7 +320,10 @@ } -ATF_TC_WITHOUT_HEAD(poll_heap_after_end); +ATF_TC(poll_heap_after_end); +ATF_TC_HEAD(poll_heap_after_end, tc) +{ +} ATF_TC_BODY(poll_heap_after_end, tc) { #define BUF __stack.__buf @@ -359,7 +377,10 @@ } -ATF_TC_WITHOUT_HEAD(ppoll_before_end); +ATF_TC(ppoll_before_end); +ATF_TC_HEAD(ppoll_before_end, tc) +{ +} ATF_TC_BODY(ppoll_before_end, tc) { #define BUF &__stack.__buf @@ -382,7 +403,10 @@ } -ATF_TC_WITHOUT_HEAD(ppoll_end); +ATF_TC(ppoll_end); +ATF_TC_HEAD(ppoll_end, tc) +{ +} ATF_TC_BODY(ppoll_end, tc) { #define BUF &__stack.__buf @@ -405,7 +429,10 @@ } -ATF_TC_WITHOUT_HEAD(ppoll_after_end); +ATF_TC(ppoll_after_end); +ATF_TC_HEAD(ppoll_after_end, tc) +{ +} ATF_TC_BODY(ppoll_after_end, tc) { #define BUF &__stack.__buf @@ -459,7 +486,10 @@ } -ATF_TC_WITHOUT_HEAD(ppoll_heap_before_end); +ATF_TC(ppoll_heap_before_end); +ATF_TC_HEAD(ppoll_heap_before_end, tc) +{ +} ATF_TC_BODY(ppoll_heap_before_end, tc) { #define BUF __stack.__buf @@ -483,7 +513,10 @@ } -ATF_TC_WITHOUT_HEAD(ppoll_heap_end); +ATF_TC(ppoll_heap_end); +ATF_TC_HEAD(ppoll_heap_end, tc) +{ +} ATF_TC_BODY(ppoll_heap_end, tc) { #define BUF __stack.__buf @@ -507,7 +540,10 @@ } -ATF_TC_WITHOUT_HEAD(ppoll_heap_after_end); +ATF_TC(ppoll_heap_after_end); +ATF_TC_HEAD(ppoll_heap_after_end, tc) +{ +} ATF_TC_BODY(ppoll_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_random_test.c b/lib/libc/tests/secure/fortify_random_test.c --- a/lib/libc/tests/secure/fortify_random_test.c +++ b/lib/libc/tests/secure/fortify_random_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(getrandom_before_end); +ATF_TC(getrandom_before_end); +ATF_TC_HEAD(getrandom_before_end, tc) +{ +} ATF_TC_BODY(getrandom_before_end, tc) { #define BUF &__stack.__buf @@ -180,7 +183,10 @@ } -ATF_TC_WITHOUT_HEAD(getrandom_end); +ATF_TC(getrandom_end); +ATF_TC_HEAD(getrandom_end, tc) +{ +} ATF_TC_BODY(getrandom_end, tc) { #define BUF &__stack.__buf @@ -198,7 +204,10 @@ } -ATF_TC_WITHOUT_HEAD(getrandom_heap_before_end); +ATF_TC(getrandom_heap_before_end); +ATF_TC_HEAD(getrandom_heap_before_end, tc) +{ +} ATF_TC_BODY(getrandom_heap_before_end, tc) { #define BUF __stack.__buf @@ -218,7 +227,10 @@ } -ATF_TC_WITHOUT_HEAD(getrandom_heap_end); +ATF_TC(getrandom_heap_end); +ATF_TC_HEAD(getrandom_heap_end, tc) +{ +} ATF_TC_BODY(getrandom_heap_end, tc) { #define BUF __stack.__buf @@ -238,7 +250,10 @@ } -ATF_TC_WITHOUT_HEAD(getrandom_heap_after_end); +ATF_TC(getrandom_heap_after_end); +ATF_TC_HEAD(getrandom_heap_after_end, tc) +{ +} ATF_TC_BODY(getrandom_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_select_test.c b/lib/libc/tests/secure/fortify_select_test.c --- a/lib/libc/tests/secure/fortify_select_test.c +++ b/lib/libc/tests/secure/fortify_select_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(FD_SET_before_end); +ATF_TC(FD_SET_before_end); +ATF_TC_HEAD(FD_SET_before_end, tc) +{ +} ATF_TC_BODY(FD_SET_before_end, tc) { #define BUF &__stack.__buf @@ -180,7 +183,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_SET_end); +ATF_TC(FD_SET_end); +ATF_TC_HEAD(FD_SET_end, tc) +{ +} ATF_TC_BODY(FD_SET_end, tc) { #define BUF &__stack.__buf @@ -198,7 +204,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_SET_after_end); +ATF_TC(FD_SET_after_end); +ATF_TC_HEAD(FD_SET_after_end, tc) +{ +} ATF_TC_BODY(FD_SET_after_end, tc) { #define BUF &__stack.__buf @@ -247,7 +256,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_SET_heap_before_end); +ATF_TC(FD_SET_heap_before_end); +ATF_TC_HEAD(FD_SET_heap_before_end, tc) +{ +} ATF_TC_BODY(FD_SET_heap_before_end, tc) { #define BUF __stack.__buf @@ -267,7 +279,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_SET_heap_end); +ATF_TC(FD_SET_heap_end); +ATF_TC_HEAD(FD_SET_heap_end, tc) +{ +} ATF_TC_BODY(FD_SET_heap_end, tc) { #define BUF __stack.__buf @@ -287,7 +302,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_SET_heap_after_end); +ATF_TC(FD_SET_heap_after_end); +ATF_TC_HEAD(FD_SET_heap_after_end, tc) +{ +} ATF_TC_BODY(FD_SET_heap_after_end, tc) { #define BUF __stack.__buf @@ -338,7 +356,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_CLR_before_end); +ATF_TC(FD_CLR_before_end); +ATF_TC_HEAD(FD_CLR_before_end, tc) +{ +} ATF_TC_BODY(FD_CLR_before_end, tc) { #define BUF &__stack.__buf @@ -356,7 +377,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_CLR_end); +ATF_TC(FD_CLR_end); +ATF_TC_HEAD(FD_CLR_end, tc) +{ +} ATF_TC_BODY(FD_CLR_end, tc) { #define BUF &__stack.__buf @@ -374,7 +398,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_CLR_after_end); +ATF_TC(FD_CLR_after_end); +ATF_TC_HEAD(FD_CLR_after_end, tc) +{ +} ATF_TC_BODY(FD_CLR_after_end, tc) { #define BUF &__stack.__buf @@ -423,7 +450,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_CLR_heap_before_end); +ATF_TC(FD_CLR_heap_before_end); +ATF_TC_HEAD(FD_CLR_heap_before_end, tc) +{ +} ATF_TC_BODY(FD_CLR_heap_before_end, tc) { #define BUF __stack.__buf @@ -443,7 +473,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_CLR_heap_end); +ATF_TC(FD_CLR_heap_end); +ATF_TC_HEAD(FD_CLR_heap_end, tc) +{ +} ATF_TC_BODY(FD_CLR_heap_end, tc) { #define BUF __stack.__buf @@ -463,7 +496,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_CLR_heap_after_end); +ATF_TC(FD_CLR_heap_after_end); +ATF_TC_HEAD(FD_CLR_heap_after_end, tc) +{ +} ATF_TC_BODY(FD_CLR_heap_after_end, tc) { #define BUF __stack.__buf @@ -514,7 +550,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_ISSET_before_end); +ATF_TC(FD_ISSET_before_end); +ATF_TC_HEAD(FD_ISSET_before_end, tc) +{ +} ATF_TC_BODY(FD_ISSET_before_end, tc) { #define BUF &__stack.__buf @@ -532,7 +571,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_ISSET_end); +ATF_TC(FD_ISSET_end); +ATF_TC_HEAD(FD_ISSET_end, tc) +{ +} ATF_TC_BODY(FD_ISSET_end, tc) { #define BUF &__stack.__buf @@ -550,7 +592,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_ISSET_after_end); +ATF_TC(FD_ISSET_after_end); +ATF_TC_HEAD(FD_ISSET_after_end, tc) +{ +} ATF_TC_BODY(FD_ISSET_after_end, tc) { #define BUF &__stack.__buf @@ -599,7 +644,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_ISSET_heap_before_end); +ATF_TC(FD_ISSET_heap_before_end); +ATF_TC_HEAD(FD_ISSET_heap_before_end, tc) +{ +} ATF_TC_BODY(FD_ISSET_heap_before_end, tc) { #define BUF __stack.__buf @@ -619,7 +667,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_ISSET_heap_end); +ATF_TC(FD_ISSET_heap_end); +ATF_TC_HEAD(FD_ISSET_heap_end, tc) +{ +} ATF_TC_BODY(FD_ISSET_heap_end, tc) { #define BUF __stack.__buf @@ -639,7 +690,10 @@ } -ATF_TC_WITHOUT_HEAD(FD_ISSET_heap_after_end); +ATF_TC(FD_ISSET_heap_after_end); +ATF_TC_HEAD(FD_ISSET_heap_after_end, tc) +{ +} ATF_TC_BODY(FD_ISSET_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_socket_test.c b/lib/libc/tests/secure/fortify_socket_test.c --- a/lib/libc/tests/secure/fortify_socket_test.c +++ b/lib/libc/tests/secure/fortify_socket_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(getpeername_before_end); +ATF_TC(getpeername_before_end); +ATF_TC_HEAD(getpeername_before_end, tc) +{ +} ATF_TC_BODY(getpeername_before_end, tc) { #define BUF &__stack.__buf @@ -184,7 +187,10 @@ } -ATF_TC_WITHOUT_HEAD(getpeername_end); +ATF_TC(getpeername_end); +ATF_TC_HEAD(getpeername_end, tc) +{ +} ATF_TC_BODY(getpeername_end, tc) { #define BUF &__stack.__buf @@ -206,7 +212,10 @@ } -ATF_TC_WITHOUT_HEAD(getpeername_heap_before_end); +ATF_TC(getpeername_heap_before_end); +ATF_TC_HEAD(getpeername_heap_before_end, tc) +{ +} ATF_TC_BODY(getpeername_heap_before_end, tc) { #define BUF __stack.__buf @@ -229,7 +238,10 @@ } -ATF_TC_WITHOUT_HEAD(getpeername_heap_end); +ATF_TC(getpeername_heap_end); +ATF_TC_HEAD(getpeername_heap_end, tc) +{ +} ATF_TC_BODY(getpeername_heap_end, tc) { #define BUF __stack.__buf @@ -252,7 +264,10 @@ } -ATF_TC_WITHOUT_HEAD(getpeername_heap_after_end); +ATF_TC(getpeername_heap_after_end); +ATF_TC_HEAD(getpeername_heap_after_end, tc) +{ +} ATF_TC_BODY(getpeername_heap_after_end, tc) { #define BUF __stack.__buf @@ -306,7 +321,10 @@ } -ATF_TC_WITHOUT_HEAD(getsockname_before_end); +ATF_TC(getsockname_before_end); +ATF_TC_HEAD(getsockname_before_end, tc) +{ +} ATF_TC_BODY(getsockname_before_end, tc) { #define BUF &__stack.__buf @@ -328,7 +346,10 @@ } -ATF_TC_WITHOUT_HEAD(getsockname_end); +ATF_TC(getsockname_end); +ATF_TC_HEAD(getsockname_end, tc) +{ +} ATF_TC_BODY(getsockname_end, tc) { #define BUF &__stack.__buf @@ -350,7 +371,10 @@ } -ATF_TC_WITHOUT_HEAD(getsockname_heap_before_end); +ATF_TC(getsockname_heap_before_end); +ATF_TC_HEAD(getsockname_heap_before_end, tc) +{ +} ATF_TC_BODY(getsockname_heap_before_end, tc) { #define BUF __stack.__buf @@ -373,7 +397,10 @@ } -ATF_TC_WITHOUT_HEAD(getsockname_heap_end); +ATF_TC(getsockname_heap_end); +ATF_TC_HEAD(getsockname_heap_end, tc) +{ +} ATF_TC_BODY(getsockname_heap_end, tc) { #define BUF __stack.__buf @@ -396,7 +423,10 @@ } -ATF_TC_WITHOUT_HEAD(getsockname_heap_after_end); +ATF_TC(getsockname_heap_after_end); +ATF_TC_HEAD(getsockname_heap_after_end, tc) +{ +} ATF_TC_BODY(getsockname_heap_after_end, tc) { #define BUF __stack.__buf @@ -450,7 +480,10 @@ } -ATF_TC_WITHOUT_HEAD(recv_before_end); +ATF_TC(recv_before_end); +ATF_TC_HEAD(recv_before_end, tc) +{ +} ATF_TC_BODY(recv_before_end, tc) { #define BUF &__stack.__buf @@ -471,7 +504,10 @@ } -ATF_TC_WITHOUT_HEAD(recv_end); +ATF_TC(recv_end); +ATF_TC_HEAD(recv_end, tc) +{ +} ATF_TC_BODY(recv_end, tc) { #define BUF &__stack.__buf @@ -492,7 +528,10 @@ } -ATF_TC_WITHOUT_HEAD(recv_heap_before_end); +ATF_TC(recv_heap_before_end); +ATF_TC_HEAD(recv_heap_before_end, tc) +{ +} ATF_TC_BODY(recv_heap_before_end, tc) { #define BUF __stack.__buf @@ -514,7 +553,10 @@ } -ATF_TC_WITHOUT_HEAD(recv_heap_end); +ATF_TC(recv_heap_end); +ATF_TC_HEAD(recv_heap_end, tc) +{ +} ATF_TC_BODY(recv_heap_end, tc) { #define BUF __stack.__buf @@ -536,7 +578,10 @@ } -ATF_TC_WITHOUT_HEAD(recv_heap_after_end); +ATF_TC(recv_heap_after_end); +ATF_TC_HEAD(recv_heap_after_end, tc) +{ +} ATF_TC_BODY(recv_heap_after_end, tc) { #define BUF __stack.__buf @@ -589,7 +634,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_before_end); +ATF_TC(recvfrom_before_end); +ATF_TC_HEAD(recvfrom_before_end, tc) +{ +} ATF_TC_BODY(recvfrom_before_end, tc) { #define BUF &__stack.__buf @@ -610,7 +658,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_end); +ATF_TC(recvfrom_end); +ATF_TC_HEAD(recvfrom_end, tc) +{ +} ATF_TC_BODY(recvfrom_end, tc) { #define BUF &__stack.__buf @@ -631,7 +682,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_heap_before_end); +ATF_TC(recvfrom_heap_before_end); +ATF_TC_HEAD(recvfrom_heap_before_end, tc) +{ +} ATF_TC_BODY(recvfrom_heap_before_end, tc) { #define BUF __stack.__buf @@ -653,7 +707,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_heap_end); +ATF_TC(recvfrom_heap_end); +ATF_TC_HEAD(recvfrom_heap_end, tc) +{ +} ATF_TC_BODY(recvfrom_heap_end, tc) { #define BUF __stack.__buf @@ -675,7 +732,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_heap_after_end); +ATF_TC(recvfrom_heap_after_end); +ATF_TC_HEAD(recvfrom_heap_after_end, tc) +{ +} ATF_TC_BODY(recvfrom_heap_after_end, tc) { #define BUF __stack.__buf @@ -728,7 +788,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_sockaddr_before_end); +ATF_TC(recvfrom_sockaddr_before_end); +ATF_TC_HEAD(recvfrom_sockaddr_before_end, tc) +{ +} ATF_TC_BODY(recvfrom_sockaddr_before_end, tc) { #define BUF &__stack.__buf @@ -752,7 +815,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_sockaddr_end); +ATF_TC(recvfrom_sockaddr_end); +ATF_TC_HEAD(recvfrom_sockaddr_end, tc) +{ +} ATF_TC_BODY(recvfrom_sockaddr_end, tc) { #define BUF &__stack.__buf @@ -776,7 +842,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_sockaddr_heap_before_end); +ATF_TC(recvfrom_sockaddr_heap_before_end); +ATF_TC_HEAD(recvfrom_sockaddr_heap_before_end, tc) +{ +} ATF_TC_BODY(recvfrom_sockaddr_heap_before_end, tc) { #define BUF __stack.__buf @@ -801,7 +870,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_sockaddr_heap_end); +ATF_TC(recvfrom_sockaddr_heap_end); +ATF_TC_HEAD(recvfrom_sockaddr_heap_end, tc) +{ +} ATF_TC_BODY(recvfrom_sockaddr_heap_end, tc) { #define BUF __stack.__buf @@ -826,7 +898,10 @@ } -ATF_TC_WITHOUT_HEAD(recvfrom_sockaddr_heap_after_end); +ATF_TC(recvfrom_sockaddr_heap_after_end); +ATF_TC_HEAD(recvfrom_sockaddr_heap_after_end, tc) +{ +} ATF_TC_BODY(recvfrom_sockaddr_heap_after_end, tc) { #define BUF __stack.__buf @@ -882,7 +957,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_name_before_end); +ATF_TC(recvmsg_msg_name_before_end); +ATF_TC_HEAD(recvmsg_msg_name_before_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_name_before_end, tc) { #define BUF &__stack.__buf @@ -906,7 +984,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_name_end); +ATF_TC(recvmsg_msg_name_end); +ATF_TC_HEAD(recvmsg_msg_name_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_name_end, tc) { #define BUF &__stack.__buf @@ -930,7 +1011,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_name_heap_before_end); +ATF_TC(recvmsg_msg_name_heap_before_end); +ATF_TC_HEAD(recvmsg_msg_name_heap_before_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_name_heap_before_end, tc) { #define BUF __stack.__buf @@ -955,7 +1039,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_name_heap_end); +ATF_TC(recvmsg_msg_name_heap_end); +ATF_TC_HEAD(recvmsg_msg_name_heap_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_name_heap_end, tc) { #define BUF __stack.__buf @@ -980,7 +1067,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_name_heap_after_end); +ATF_TC(recvmsg_msg_name_heap_after_end); +ATF_TC_HEAD(recvmsg_msg_name_heap_after_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_name_heap_after_end, tc) { #define BUF __stack.__buf @@ -1036,7 +1126,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_iov_before_end); +ATF_TC(recvmsg_msg_iov_before_end); +ATF_TC_HEAD(recvmsg_msg_iov_before_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_iov_before_end, tc) { #define BUF &__stack.__buf @@ -1070,7 +1163,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_iov_end); +ATF_TC(recvmsg_msg_iov_end); +ATF_TC_HEAD(recvmsg_msg_iov_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_iov_end, tc) { #define BUF &__stack.__buf @@ -1104,7 +1200,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_iov_heap_before_end); +ATF_TC(recvmsg_msg_iov_heap_before_end); +ATF_TC_HEAD(recvmsg_msg_iov_heap_before_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_iov_heap_before_end, tc) { #define BUF __stack.__buf @@ -1139,7 +1238,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_iov_heap_end); +ATF_TC(recvmsg_msg_iov_heap_end); +ATF_TC_HEAD(recvmsg_msg_iov_heap_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_iov_heap_end, tc) { #define BUF __stack.__buf @@ -1174,7 +1276,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_iov_heap_after_end); +ATF_TC(recvmsg_msg_iov_heap_after_end); +ATF_TC_HEAD(recvmsg_msg_iov_heap_after_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_iov_heap_after_end, tc) { #define BUF __stack.__buf @@ -1240,7 +1345,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_control_before_end); +ATF_TC(recvmsg_msg_control_before_end); +ATF_TC_HEAD(recvmsg_msg_control_before_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_control_before_end, tc) { #define BUF &__stack.__buf @@ -1265,7 +1373,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_control_end); +ATF_TC(recvmsg_msg_control_end); +ATF_TC_HEAD(recvmsg_msg_control_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_control_end, tc) { #define BUF &__stack.__buf @@ -1290,7 +1401,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_control_heap_before_end); +ATF_TC(recvmsg_msg_control_heap_before_end); +ATF_TC_HEAD(recvmsg_msg_control_heap_before_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_control_heap_before_end, tc) { #define BUF __stack.__buf @@ -1316,7 +1430,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_control_heap_end); +ATF_TC(recvmsg_msg_control_heap_end); +ATF_TC_HEAD(recvmsg_msg_control_heap_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_control_heap_end, tc) { #define BUF __stack.__buf @@ -1342,7 +1459,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmsg_msg_control_heap_after_end); +ATF_TC(recvmsg_msg_control_heap_after_end); +ATF_TC_HEAD(recvmsg_msg_control_heap_after_end, tc) +{ +} ATF_TC_BODY(recvmsg_msg_control_heap_after_end, tc) { #define BUF __stack.__buf @@ -1399,7 +1519,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msgvec_before_end); +ATF_TC(recvmmsg_msgvec_before_end); +ATF_TC_HEAD(recvmmsg_msgvec_before_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msgvec_before_end, tc) { #define BUF &__stack.__buf @@ -1418,7 +1541,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msgvec_end); +ATF_TC(recvmmsg_msgvec_end); +ATF_TC_HEAD(recvmmsg_msgvec_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msgvec_end, tc) { #define BUF &__stack.__buf @@ -1437,7 +1563,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msgvec_after_end); +ATF_TC(recvmmsg_msgvec_after_end); +ATF_TC_HEAD(recvmmsg_msgvec_after_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msgvec_after_end, tc) { #define BUF &__stack.__buf @@ -1487,7 +1616,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msgvec_heap_before_end); +ATF_TC(recvmmsg_msgvec_heap_before_end); +ATF_TC_HEAD(recvmmsg_msgvec_heap_before_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msgvec_heap_before_end, tc) { #define BUF __stack.__buf @@ -1508,7 +1640,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msgvec_heap_end); +ATF_TC(recvmmsg_msgvec_heap_end); +ATF_TC_HEAD(recvmmsg_msgvec_heap_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msgvec_heap_end, tc) { #define BUF __stack.__buf @@ -1529,7 +1664,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msgvec_heap_after_end); +ATF_TC(recvmmsg_msgvec_heap_after_end); +ATF_TC_HEAD(recvmmsg_msgvec_heap_after_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msgvec_heap_after_end, tc) { #define BUF __stack.__buf @@ -1581,7 +1719,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msghdr_before_end); +ATF_TC(recvmmsg_msghdr_before_end); +ATF_TC_HEAD(recvmmsg_msghdr_before_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msghdr_before_end, tc) { #define BUF &__stack.__buf @@ -1610,7 +1751,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msghdr_end); +ATF_TC(recvmmsg_msghdr_end); +ATF_TC_HEAD(recvmmsg_msghdr_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msghdr_end, tc) { #define BUF &__stack.__buf @@ -1639,7 +1783,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msghdr_heap_before_end); +ATF_TC(recvmmsg_msghdr_heap_before_end); +ATF_TC_HEAD(recvmmsg_msghdr_heap_before_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msghdr_heap_before_end, tc) { #define BUF __stack.__buf @@ -1669,7 +1816,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msghdr_heap_end); +ATF_TC(recvmmsg_msghdr_heap_end); +ATF_TC_HEAD(recvmmsg_msghdr_heap_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msghdr_heap_end, tc) { #define BUF __stack.__buf @@ -1699,7 +1849,10 @@ } -ATF_TC_WITHOUT_HEAD(recvmmsg_msghdr_heap_after_end); +ATF_TC(recvmmsg_msghdr_heap_after_end); +ATF_TC_HEAD(recvmmsg_msghdr_heap_after_end, tc) +{ +} ATF_TC_BODY(recvmmsg_msghdr_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_stdio_test.c b/lib/libc/tests/secure/fortify_stdio_test.c --- a/lib/libc/tests/secure/fortify_stdio_test.c +++ b/lib/libc/tests/secure/fortify_stdio_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(ctermid_before_end); +ATF_TC(ctermid_before_end); +ATF_TC_HEAD(ctermid_before_end, tc) +{ +} ATF_TC_BODY(ctermid_before_end, tc) { #define BUF &__stack.__buf @@ -180,7 +183,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_end); +ATF_TC(ctermid_end); +ATF_TC_HEAD(ctermid_end, tc) +{ +} ATF_TC_BODY(ctermid_end, tc) { #define BUF &__stack.__buf @@ -198,7 +204,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_heap_before_end); +ATF_TC(ctermid_heap_before_end); +ATF_TC_HEAD(ctermid_heap_before_end, tc) +{ +} ATF_TC_BODY(ctermid_heap_before_end, tc) { #define BUF __stack.__buf @@ -218,7 +227,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_heap_end); +ATF_TC(ctermid_heap_end); +ATF_TC_HEAD(ctermid_heap_end, tc) +{ +} ATF_TC_BODY(ctermid_heap_end, tc) { #define BUF __stack.__buf @@ -238,7 +250,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_heap_after_end); +ATF_TC(ctermid_heap_after_end); +ATF_TC_HEAD(ctermid_heap_after_end, tc) +{ +} ATF_TC_BODY(ctermid_heap_after_end, tc) { #define BUF __stack.__buf @@ -289,7 +304,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_r_before_end); +ATF_TC(ctermid_r_before_end); +ATF_TC_HEAD(ctermid_r_before_end, tc) +{ +} ATF_TC_BODY(ctermid_r_before_end, tc) { #define BUF &__stack.__buf @@ -307,7 +325,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_r_end); +ATF_TC(ctermid_r_end); +ATF_TC_HEAD(ctermid_r_end, tc) +{ +} ATF_TC_BODY(ctermid_r_end, tc) { #define BUF &__stack.__buf @@ -325,7 +346,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_r_heap_before_end); +ATF_TC(ctermid_r_heap_before_end); +ATF_TC_HEAD(ctermid_r_heap_before_end, tc) +{ +} ATF_TC_BODY(ctermid_r_heap_before_end, tc) { #define BUF __stack.__buf @@ -345,7 +369,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_r_heap_end); +ATF_TC(ctermid_r_heap_end); +ATF_TC_HEAD(ctermid_r_heap_end, tc) +{ +} ATF_TC_BODY(ctermid_r_heap_end, tc) { #define BUF __stack.__buf @@ -365,7 +392,10 @@ } -ATF_TC_WITHOUT_HEAD(ctermid_r_heap_after_end); +ATF_TC(ctermid_r_heap_after_end); +ATF_TC_HEAD(ctermid_r_heap_after_end, tc) +{ +} ATF_TC_BODY(ctermid_r_heap_after_end, tc) { #define BUF __stack.__buf @@ -416,7 +446,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_before_end); +ATF_TC(fread_before_end); +ATF_TC_HEAD(fread_before_end, tc) +{ +} ATF_TC_BODY(fread_before_end, tc) { #define BUF &__stack.__buf @@ -436,7 +469,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_end); +ATF_TC(fread_end); +ATF_TC_HEAD(fread_end, tc) +{ +} ATF_TC_BODY(fread_end, tc) { #define BUF &__stack.__buf @@ -456,7 +492,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_heap_before_end); +ATF_TC(fread_heap_before_end); +ATF_TC_HEAD(fread_heap_before_end, tc) +{ +} ATF_TC_BODY(fread_heap_before_end, tc) { #define BUF __stack.__buf @@ -477,7 +516,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_heap_end); +ATF_TC(fread_heap_end); +ATF_TC_HEAD(fread_heap_end, tc) +{ +} ATF_TC_BODY(fread_heap_end, tc) { #define BUF __stack.__buf @@ -498,7 +540,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_heap_after_end); +ATF_TC(fread_heap_after_end); +ATF_TC_HEAD(fread_heap_after_end, tc) +{ +} ATF_TC_BODY(fread_heap_after_end, tc) { #define BUF __stack.__buf @@ -550,7 +595,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_unlocked_before_end); +ATF_TC(fread_unlocked_before_end); +ATF_TC_HEAD(fread_unlocked_before_end, tc) +{ +} ATF_TC_BODY(fread_unlocked_before_end, tc) { #define BUF &__stack.__buf @@ -570,7 +618,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_unlocked_end); +ATF_TC(fread_unlocked_end); +ATF_TC_HEAD(fread_unlocked_end, tc) +{ +} ATF_TC_BODY(fread_unlocked_end, tc) { #define BUF &__stack.__buf @@ -590,7 +641,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_unlocked_heap_before_end); +ATF_TC(fread_unlocked_heap_before_end); +ATF_TC_HEAD(fread_unlocked_heap_before_end, tc) +{ +} ATF_TC_BODY(fread_unlocked_heap_before_end, tc) { #define BUF __stack.__buf @@ -611,7 +665,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_unlocked_heap_end); +ATF_TC(fread_unlocked_heap_end); +ATF_TC_HEAD(fread_unlocked_heap_end, tc) +{ +} ATF_TC_BODY(fread_unlocked_heap_end, tc) { #define BUF __stack.__buf @@ -632,7 +689,10 @@ } -ATF_TC_WITHOUT_HEAD(fread_unlocked_heap_after_end); +ATF_TC(fread_unlocked_heap_after_end); +ATF_TC_HEAD(fread_unlocked_heap_after_end, tc) +{ +} ATF_TC_BODY(fread_unlocked_heap_after_end, tc) { #define BUF __stack.__buf @@ -684,7 +744,10 @@ } -ATF_TC_WITHOUT_HEAD(gets_s_before_end); +ATF_TC(gets_s_before_end); +ATF_TC_HEAD(gets_s_before_end, tc) +{ +} ATF_TC_BODY(gets_s_before_end, tc) { #define BUF &__stack.__buf @@ -704,7 +767,10 @@ } -ATF_TC_WITHOUT_HEAD(gets_s_end); +ATF_TC(gets_s_end); +ATF_TC_HEAD(gets_s_end, tc) +{ +} ATF_TC_BODY(gets_s_end, tc) { #define BUF &__stack.__buf @@ -724,7 +790,10 @@ } -ATF_TC_WITHOUT_HEAD(gets_s_heap_before_end); +ATF_TC(gets_s_heap_before_end); +ATF_TC_HEAD(gets_s_heap_before_end, tc) +{ +} ATF_TC_BODY(gets_s_heap_before_end, tc) { #define BUF __stack.__buf @@ -745,7 +814,10 @@ } -ATF_TC_WITHOUT_HEAD(gets_s_heap_end); +ATF_TC(gets_s_heap_end); +ATF_TC_HEAD(gets_s_heap_end, tc) +{ +} ATF_TC_BODY(gets_s_heap_end, tc) { #define BUF __stack.__buf @@ -766,7 +838,10 @@ } -ATF_TC_WITHOUT_HEAD(gets_s_heap_after_end); +ATF_TC(gets_s_heap_after_end); +ATF_TC_HEAD(gets_s_heap_after_end, tc) +{ +} ATF_TC_BODY(gets_s_heap_after_end, tc) { #define BUF __stack.__buf @@ -818,7 +893,10 @@ } -ATF_TC_WITHOUT_HEAD(sprintf_before_end); +ATF_TC(sprintf_before_end); +ATF_TC_HEAD(sprintf_before_end, tc) +{ +} ATF_TC_BODY(sprintf_before_end, tc) { #define BUF &__stack.__buf @@ -840,7 +918,10 @@ } -ATF_TC_WITHOUT_HEAD(sprintf_end); +ATF_TC(sprintf_end); +ATF_TC_HEAD(sprintf_end, tc) +{ +} ATF_TC_BODY(sprintf_end, tc) { #define BUF &__stack.__buf @@ -862,7 +943,10 @@ } -ATF_TC_WITHOUT_HEAD(sprintf_heap_before_end); +ATF_TC(sprintf_heap_before_end); +ATF_TC_HEAD(sprintf_heap_before_end, tc) +{ +} ATF_TC_BODY(sprintf_heap_before_end, tc) { #define BUF __stack.__buf @@ -885,7 +969,10 @@ } -ATF_TC_WITHOUT_HEAD(sprintf_heap_end); +ATF_TC(sprintf_heap_end); +ATF_TC_HEAD(sprintf_heap_end, tc) +{ +} ATF_TC_BODY(sprintf_heap_end, tc) { #define BUF __stack.__buf @@ -908,7 +995,10 @@ } -ATF_TC_WITHOUT_HEAD(sprintf_heap_after_end); +ATF_TC(sprintf_heap_after_end); +ATF_TC_HEAD(sprintf_heap_after_end, tc) +{ +} ATF_TC_BODY(sprintf_heap_after_end, tc) { #define BUF __stack.__buf @@ -962,7 +1052,10 @@ } -ATF_TC_WITHOUT_HEAD(snprintf_before_end); +ATF_TC(snprintf_before_end); +ATF_TC_HEAD(snprintf_before_end, tc) +{ +} ATF_TC_BODY(snprintf_before_end, tc) { #define BUF &__stack.__buf @@ -984,7 +1077,10 @@ } -ATF_TC_WITHOUT_HEAD(snprintf_end); +ATF_TC(snprintf_end); +ATF_TC_HEAD(snprintf_end, tc) +{ +} ATF_TC_BODY(snprintf_end, tc) { #define BUF &__stack.__buf @@ -1006,7 +1102,10 @@ } -ATF_TC_WITHOUT_HEAD(snprintf_heap_before_end); +ATF_TC(snprintf_heap_before_end); +ATF_TC_HEAD(snprintf_heap_before_end, tc) +{ +} ATF_TC_BODY(snprintf_heap_before_end, tc) { #define BUF __stack.__buf @@ -1029,7 +1128,10 @@ } -ATF_TC_WITHOUT_HEAD(snprintf_heap_end); +ATF_TC(snprintf_heap_end); +ATF_TC_HEAD(snprintf_heap_end, tc) +{ +} ATF_TC_BODY(snprintf_heap_end, tc) { #define BUF __stack.__buf @@ -1052,7 +1154,10 @@ } -ATF_TC_WITHOUT_HEAD(snprintf_heap_after_end); +ATF_TC(snprintf_heap_after_end); +ATF_TC_HEAD(snprintf_heap_after_end, tc) +{ +} ATF_TC_BODY(snprintf_heap_after_end, tc) { #define BUF __stack.__buf @@ -1106,7 +1211,10 @@ } -ATF_TC_WITHOUT_HEAD(tmpnam_before_end); +ATF_TC(tmpnam_before_end); +ATF_TC_HEAD(tmpnam_before_end, tc) +{ +} ATF_TC_BODY(tmpnam_before_end, tc) { #define BUF &__stack.__buf @@ -1124,7 +1232,10 @@ } -ATF_TC_WITHOUT_HEAD(tmpnam_end); +ATF_TC(tmpnam_end); +ATF_TC_HEAD(tmpnam_end, tc) +{ +} ATF_TC_BODY(tmpnam_end, tc) { #define BUF &__stack.__buf @@ -1142,7 +1253,10 @@ } -ATF_TC_WITHOUT_HEAD(tmpnam_heap_before_end); +ATF_TC(tmpnam_heap_before_end); +ATF_TC_HEAD(tmpnam_heap_before_end, tc) +{ +} ATF_TC_BODY(tmpnam_heap_before_end, tc) { #define BUF __stack.__buf @@ -1162,7 +1276,10 @@ } -ATF_TC_WITHOUT_HEAD(tmpnam_heap_end); +ATF_TC(tmpnam_heap_end); +ATF_TC_HEAD(tmpnam_heap_end, tc) +{ +} ATF_TC_BODY(tmpnam_heap_end, tc) { #define BUF __stack.__buf @@ -1182,7 +1299,10 @@ } -ATF_TC_WITHOUT_HEAD(tmpnam_heap_after_end); +ATF_TC(tmpnam_heap_after_end); +ATF_TC_HEAD(tmpnam_heap_after_end, tc) +{ +} ATF_TC_BODY(tmpnam_heap_after_end, tc) { #define BUF __stack.__buf @@ -1233,7 +1353,10 @@ } -ATF_TC_WITHOUT_HEAD(fgets_before_end); +ATF_TC(fgets_before_end); +ATF_TC_HEAD(fgets_before_end, tc) +{ +} ATF_TC_BODY(fgets_before_end, tc) { #define BUF &__stack.__buf @@ -1254,7 +1377,10 @@ } -ATF_TC_WITHOUT_HEAD(fgets_end); +ATF_TC(fgets_end); +ATF_TC_HEAD(fgets_end, tc) +{ +} ATF_TC_BODY(fgets_end, tc) { #define BUF &__stack.__buf @@ -1275,7 +1401,10 @@ } -ATF_TC_WITHOUT_HEAD(fgets_heap_before_end); +ATF_TC(fgets_heap_before_end); +ATF_TC_HEAD(fgets_heap_before_end, tc) +{ +} ATF_TC_BODY(fgets_heap_before_end, tc) { #define BUF __stack.__buf @@ -1297,7 +1426,10 @@ } -ATF_TC_WITHOUT_HEAD(fgets_heap_end); +ATF_TC(fgets_heap_end); +ATF_TC_HEAD(fgets_heap_end, tc) +{ +} ATF_TC_BODY(fgets_heap_end, tc) { #define BUF __stack.__buf @@ -1319,7 +1451,10 @@ } -ATF_TC_WITHOUT_HEAD(fgets_heap_after_end); +ATF_TC(fgets_heap_after_end); +ATF_TC_HEAD(fgets_heap_after_end, tc) +{ +} ATF_TC_BODY(fgets_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_stdlib_test.c b/lib/libc/tests/secure/fortify_stdlib_test.c --- a/lib/libc/tests/secure/fortify_stdlib_test.c +++ b/lib/libc/tests/secure/fortify_stdlib_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(arc4random_buf_before_end); +ATF_TC(arc4random_buf_before_end); +ATF_TC_HEAD(arc4random_buf_before_end, tc) +{ +} ATF_TC_BODY(arc4random_buf_before_end, tc) { #define BUF &__stack.__buf @@ -180,7 +183,10 @@ } -ATF_TC_WITHOUT_HEAD(arc4random_buf_end); +ATF_TC(arc4random_buf_end); +ATF_TC_HEAD(arc4random_buf_end, tc) +{ +} ATF_TC_BODY(arc4random_buf_end, tc) { #define BUF &__stack.__buf @@ -198,7 +204,10 @@ } -ATF_TC_WITHOUT_HEAD(arc4random_buf_heap_before_end); +ATF_TC(arc4random_buf_heap_before_end); +ATF_TC_HEAD(arc4random_buf_heap_before_end, tc) +{ +} ATF_TC_BODY(arc4random_buf_heap_before_end, tc) { #define BUF __stack.__buf @@ -218,7 +227,10 @@ } -ATF_TC_WITHOUT_HEAD(arc4random_buf_heap_end); +ATF_TC(arc4random_buf_heap_end); +ATF_TC_HEAD(arc4random_buf_heap_end, tc) +{ +} ATF_TC_BODY(arc4random_buf_heap_end, tc) { #define BUF __stack.__buf @@ -238,7 +250,10 @@ } -ATF_TC_WITHOUT_HEAD(arc4random_buf_heap_after_end); +ATF_TC(arc4random_buf_heap_after_end); +ATF_TC_HEAD(arc4random_buf_heap_after_end, tc) +{ +} ATF_TC_BODY(arc4random_buf_heap_after_end, tc) { #define BUF __stack.__buf @@ -289,7 +304,10 @@ } -ATF_TC_WITHOUT_HEAD(realpath_before_end); +ATF_TC(realpath_before_end); +ATF_TC_HEAD(realpath_before_end, tc) +{ +} ATF_TC_BODY(realpath_before_end, tc) { #define BUF &__stack.__buf @@ -307,7 +325,10 @@ } -ATF_TC_WITHOUT_HEAD(realpath_end); +ATF_TC(realpath_end); +ATF_TC_HEAD(realpath_end, tc) +{ +} ATF_TC_BODY(realpath_end, tc) { #define BUF &__stack.__buf @@ -325,7 +346,10 @@ } -ATF_TC_WITHOUT_HEAD(realpath_heap_before_end); +ATF_TC(realpath_heap_before_end); +ATF_TC_HEAD(realpath_heap_before_end, tc) +{ +} ATF_TC_BODY(realpath_heap_before_end, tc) { #define BUF __stack.__buf @@ -345,7 +369,10 @@ } -ATF_TC_WITHOUT_HEAD(realpath_heap_end); +ATF_TC(realpath_heap_end); +ATF_TC_HEAD(realpath_heap_end, tc) +{ +} ATF_TC_BODY(realpath_heap_end, tc) { #define BUF __stack.__buf @@ -365,7 +392,10 @@ } -ATF_TC_WITHOUT_HEAD(realpath_heap_after_end); +ATF_TC(realpath_heap_after_end); +ATF_TC_HEAD(realpath_heap_after_end, tc) +{ +} ATF_TC_BODY(realpath_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_string_test.c b/lib/libc/tests/secure/fortify_string_test.c --- a/lib/libc/tests/secure/fortify_string_test.c +++ b/lib/libc/tests/secure/fortify_string_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(memcpy_before_end); +ATF_TC(memcpy_before_end); +ATF_TC_HEAD(memcpy_before_end, tc) +{ +} ATF_TC_BODY(memcpy_before_end, tc) { #define BUF &__stack.__buf @@ -181,7 +184,10 @@ } -ATF_TC_WITHOUT_HEAD(memcpy_end); +ATF_TC(memcpy_end); +ATF_TC_HEAD(memcpy_end, tc) +{ +} ATF_TC_BODY(memcpy_end, tc) { #define BUF &__stack.__buf @@ -200,7 +206,10 @@ } -ATF_TC_WITHOUT_HEAD(memcpy_heap_before_end); +ATF_TC(memcpy_heap_before_end); +ATF_TC_HEAD(memcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(memcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -221,7 +230,10 @@ } -ATF_TC_WITHOUT_HEAD(memcpy_heap_end); +ATF_TC(memcpy_heap_end); +ATF_TC_HEAD(memcpy_heap_end, tc) +{ +} ATF_TC_BODY(memcpy_heap_end, tc) { #define BUF __stack.__buf @@ -242,7 +254,10 @@ } -ATF_TC_WITHOUT_HEAD(memcpy_heap_after_end); +ATF_TC(memcpy_heap_after_end); +ATF_TC_HEAD(memcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(memcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -294,7 +309,10 @@ } -ATF_TC_WITHOUT_HEAD(mempcpy_before_end); +ATF_TC(mempcpy_before_end); +ATF_TC_HEAD(mempcpy_before_end, tc) +{ +} ATF_TC_BODY(mempcpy_before_end, tc) { #define BUF &__stack.__buf @@ -313,7 +331,10 @@ } -ATF_TC_WITHOUT_HEAD(mempcpy_end); +ATF_TC(mempcpy_end); +ATF_TC_HEAD(mempcpy_end, tc) +{ +} ATF_TC_BODY(mempcpy_end, tc) { #define BUF &__stack.__buf @@ -332,7 +353,10 @@ } -ATF_TC_WITHOUT_HEAD(mempcpy_heap_before_end); +ATF_TC(mempcpy_heap_before_end); +ATF_TC_HEAD(mempcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(mempcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -353,7 +377,10 @@ } -ATF_TC_WITHOUT_HEAD(mempcpy_heap_end); +ATF_TC(mempcpy_heap_end); +ATF_TC_HEAD(mempcpy_heap_end, tc) +{ +} ATF_TC_BODY(mempcpy_heap_end, tc) { #define BUF __stack.__buf @@ -374,7 +401,10 @@ } -ATF_TC_WITHOUT_HEAD(mempcpy_heap_after_end); +ATF_TC(mempcpy_heap_after_end); +ATF_TC_HEAD(mempcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(mempcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -426,7 +456,10 @@ } -ATF_TC_WITHOUT_HEAD(memmove_before_end); +ATF_TC(memmove_before_end); +ATF_TC_HEAD(memmove_before_end, tc) +{ +} ATF_TC_BODY(memmove_before_end, tc) { #define BUF &__stack.__buf @@ -445,7 +478,10 @@ } -ATF_TC_WITHOUT_HEAD(memmove_end); +ATF_TC(memmove_end); +ATF_TC_HEAD(memmove_end, tc) +{ +} ATF_TC_BODY(memmove_end, tc) { #define BUF &__stack.__buf @@ -464,7 +500,10 @@ } -ATF_TC_WITHOUT_HEAD(memmove_heap_before_end); +ATF_TC(memmove_heap_before_end); +ATF_TC_HEAD(memmove_heap_before_end, tc) +{ +} ATF_TC_BODY(memmove_heap_before_end, tc) { #define BUF __stack.__buf @@ -485,7 +524,10 @@ } -ATF_TC_WITHOUT_HEAD(memmove_heap_end); +ATF_TC(memmove_heap_end); +ATF_TC_HEAD(memmove_heap_end, tc) +{ +} ATF_TC_BODY(memmove_heap_end, tc) { #define BUF __stack.__buf @@ -506,7 +548,10 @@ } -ATF_TC_WITHOUT_HEAD(memmove_heap_after_end); +ATF_TC(memmove_heap_after_end); +ATF_TC_HEAD(memmove_heap_after_end, tc) +{ +} ATF_TC_BODY(memmove_heap_after_end, tc) { #define BUF __stack.__buf @@ -558,7 +603,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_before_end); +ATF_TC(memset_before_end); +ATF_TC_HEAD(memset_before_end, tc) +{ +} ATF_TC_BODY(memset_before_end, tc) { #define BUF &__stack.__buf @@ -576,7 +624,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_end); +ATF_TC(memset_end); +ATF_TC_HEAD(memset_end, tc) +{ +} ATF_TC_BODY(memset_end, tc) { #define BUF &__stack.__buf @@ -594,7 +645,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_heap_before_end); +ATF_TC(memset_heap_before_end); +ATF_TC_HEAD(memset_heap_before_end, tc) +{ +} ATF_TC_BODY(memset_heap_before_end, tc) { #define BUF __stack.__buf @@ -614,7 +668,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_heap_end); +ATF_TC(memset_heap_end); +ATF_TC_HEAD(memset_heap_end, tc) +{ +} ATF_TC_BODY(memset_heap_end, tc) { #define BUF __stack.__buf @@ -634,7 +691,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_heap_after_end); +ATF_TC(memset_heap_after_end); +ATF_TC_HEAD(memset_heap_after_end, tc) +{ +} ATF_TC_BODY(memset_heap_after_end, tc) { #define BUF __stack.__buf @@ -685,7 +745,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_explicit_before_end); +ATF_TC(memset_explicit_before_end); +ATF_TC_HEAD(memset_explicit_before_end, tc) +{ +} ATF_TC_BODY(memset_explicit_before_end, tc) { #define BUF &__stack.__buf @@ -703,7 +766,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_explicit_end); +ATF_TC(memset_explicit_end); +ATF_TC_HEAD(memset_explicit_end, tc) +{ +} ATF_TC_BODY(memset_explicit_end, tc) { #define BUF &__stack.__buf @@ -721,7 +787,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_explicit_heap_before_end); +ATF_TC(memset_explicit_heap_before_end); +ATF_TC_HEAD(memset_explicit_heap_before_end, tc) +{ +} ATF_TC_BODY(memset_explicit_heap_before_end, tc) { #define BUF __stack.__buf @@ -741,7 +810,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_explicit_heap_end); +ATF_TC(memset_explicit_heap_end); +ATF_TC_HEAD(memset_explicit_heap_end, tc) +{ +} ATF_TC_BODY(memset_explicit_heap_end, tc) { #define BUF __stack.__buf @@ -761,7 +833,10 @@ } -ATF_TC_WITHOUT_HEAD(memset_explicit_heap_after_end); +ATF_TC(memset_explicit_heap_after_end); +ATF_TC_HEAD(memset_explicit_heap_after_end, tc) +{ +} ATF_TC_BODY(memset_explicit_heap_after_end, tc) { #define BUF __stack.__buf @@ -812,7 +887,10 @@ } -ATF_TC_WITHOUT_HEAD(stpcpy_before_end); +ATF_TC(stpcpy_before_end); +ATF_TC_HEAD(stpcpy_before_end, tc) +{ +} ATF_TC_BODY(stpcpy_before_end, tc) { #define BUF &__stack.__buf @@ -835,7 +913,10 @@ } -ATF_TC_WITHOUT_HEAD(stpcpy_end); +ATF_TC(stpcpy_end); +ATF_TC_HEAD(stpcpy_end, tc) +{ +} ATF_TC_BODY(stpcpy_end, tc) { #define BUF &__stack.__buf @@ -858,7 +939,10 @@ } -ATF_TC_WITHOUT_HEAD(stpcpy_heap_before_end); +ATF_TC(stpcpy_heap_before_end); +ATF_TC_HEAD(stpcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(stpcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -882,7 +966,10 @@ } -ATF_TC_WITHOUT_HEAD(stpcpy_heap_end); +ATF_TC(stpcpy_heap_end); +ATF_TC_HEAD(stpcpy_heap_end, tc) +{ +} ATF_TC_BODY(stpcpy_heap_end, tc) { #define BUF __stack.__buf @@ -906,7 +993,10 @@ } -ATF_TC_WITHOUT_HEAD(stpcpy_heap_after_end); +ATF_TC(stpcpy_heap_after_end); +ATF_TC_HEAD(stpcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(stpcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -961,7 +1051,10 @@ } -ATF_TC_WITHOUT_HEAD(stpncpy_before_end); +ATF_TC(stpncpy_before_end); +ATF_TC_HEAD(stpncpy_before_end, tc) +{ +} ATF_TC_BODY(stpncpy_before_end, tc) { #define BUF &__stack.__buf @@ -984,7 +1077,10 @@ } -ATF_TC_WITHOUT_HEAD(stpncpy_end); +ATF_TC(stpncpy_end); +ATF_TC_HEAD(stpncpy_end, tc) +{ +} ATF_TC_BODY(stpncpy_end, tc) { #define BUF &__stack.__buf @@ -1007,7 +1103,10 @@ } -ATF_TC_WITHOUT_HEAD(stpncpy_heap_before_end); +ATF_TC(stpncpy_heap_before_end); +ATF_TC_HEAD(stpncpy_heap_before_end, tc) +{ +} ATF_TC_BODY(stpncpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1031,7 +1130,10 @@ } -ATF_TC_WITHOUT_HEAD(stpncpy_heap_end); +ATF_TC(stpncpy_heap_end); +ATF_TC_HEAD(stpncpy_heap_end, tc) +{ +} ATF_TC_BODY(stpncpy_heap_end, tc) { #define BUF __stack.__buf @@ -1055,7 +1157,10 @@ } -ATF_TC_WITHOUT_HEAD(stpncpy_heap_after_end); +ATF_TC(stpncpy_heap_after_end); +ATF_TC_HEAD(stpncpy_heap_after_end, tc) +{ +} ATF_TC_BODY(stpncpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -1110,7 +1215,10 @@ } -ATF_TC_WITHOUT_HEAD(strcat_before_end); +ATF_TC(strcat_before_end); +ATF_TC_HEAD(strcat_before_end, tc) +{ +} ATF_TC_BODY(strcat_before_end, tc) { #define BUF &__stack.__buf @@ -1133,7 +1241,10 @@ } -ATF_TC_WITHOUT_HEAD(strcat_end); +ATF_TC(strcat_end); +ATF_TC_HEAD(strcat_end, tc) +{ +} ATF_TC_BODY(strcat_end, tc) { #define BUF &__stack.__buf @@ -1156,7 +1267,10 @@ } -ATF_TC_WITHOUT_HEAD(strcat_heap_before_end); +ATF_TC(strcat_heap_before_end); +ATF_TC_HEAD(strcat_heap_before_end, tc) +{ +} ATF_TC_BODY(strcat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1180,7 +1294,10 @@ } -ATF_TC_WITHOUT_HEAD(strcat_heap_end); +ATF_TC(strcat_heap_end); +ATF_TC_HEAD(strcat_heap_end, tc) +{ +} ATF_TC_BODY(strcat_heap_end, tc) { #define BUF __stack.__buf @@ -1204,7 +1321,10 @@ } -ATF_TC_WITHOUT_HEAD(strcat_heap_after_end); +ATF_TC(strcat_heap_after_end); +ATF_TC_HEAD(strcat_heap_after_end, tc) +{ +} ATF_TC_BODY(strcat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1259,7 +1379,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcat_before_end); +ATF_TC(strlcat_before_end); +ATF_TC_HEAD(strlcat_before_end, tc) +{ +} ATF_TC_BODY(strlcat_before_end, tc) { #define BUF &__stack.__buf @@ -1282,7 +1405,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcat_end); +ATF_TC(strlcat_end); +ATF_TC_HEAD(strlcat_end, tc) +{ +} ATF_TC_BODY(strlcat_end, tc) { #define BUF &__stack.__buf @@ -1305,7 +1431,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcat_heap_before_end); +ATF_TC(strlcat_heap_before_end); +ATF_TC_HEAD(strlcat_heap_before_end, tc) +{ +} ATF_TC_BODY(strlcat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1329,7 +1458,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcat_heap_end); +ATF_TC(strlcat_heap_end); +ATF_TC_HEAD(strlcat_heap_end, tc) +{ +} ATF_TC_BODY(strlcat_heap_end, tc) { #define BUF __stack.__buf @@ -1353,7 +1485,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcat_heap_after_end); +ATF_TC(strlcat_heap_after_end); +ATF_TC_HEAD(strlcat_heap_after_end, tc) +{ +} ATF_TC_BODY(strlcat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1408,7 +1543,10 @@ } -ATF_TC_WITHOUT_HEAD(strncat_before_end); +ATF_TC(strncat_before_end); +ATF_TC_HEAD(strncat_before_end, tc) +{ +} ATF_TC_BODY(strncat_before_end, tc) { #define BUF &__stack.__buf @@ -1431,7 +1569,10 @@ } -ATF_TC_WITHOUT_HEAD(strncat_end); +ATF_TC(strncat_end); +ATF_TC_HEAD(strncat_end, tc) +{ +} ATF_TC_BODY(strncat_end, tc) { #define BUF &__stack.__buf @@ -1454,7 +1595,10 @@ } -ATF_TC_WITHOUT_HEAD(strncat_heap_before_end); +ATF_TC(strncat_heap_before_end); +ATF_TC_HEAD(strncat_heap_before_end, tc) +{ +} ATF_TC_BODY(strncat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1478,7 +1622,10 @@ } -ATF_TC_WITHOUT_HEAD(strncat_heap_end); +ATF_TC(strncat_heap_end); +ATF_TC_HEAD(strncat_heap_end, tc) +{ +} ATF_TC_BODY(strncat_heap_end, tc) { #define BUF __stack.__buf @@ -1502,7 +1649,10 @@ } -ATF_TC_WITHOUT_HEAD(strncat_heap_after_end); +ATF_TC(strncat_heap_after_end); +ATF_TC_HEAD(strncat_heap_after_end, tc) +{ +} ATF_TC_BODY(strncat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1557,7 +1707,10 @@ } -ATF_TC_WITHOUT_HEAD(strcpy_before_end); +ATF_TC(strcpy_before_end); +ATF_TC_HEAD(strcpy_before_end, tc) +{ +} ATF_TC_BODY(strcpy_before_end, tc) { #define BUF &__stack.__buf @@ -1580,7 +1733,10 @@ } -ATF_TC_WITHOUT_HEAD(strcpy_end); +ATF_TC(strcpy_end); +ATF_TC_HEAD(strcpy_end, tc) +{ +} ATF_TC_BODY(strcpy_end, tc) { #define BUF &__stack.__buf @@ -1603,7 +1759,10 @@ } -ATF_TC_WITHOUT_HEAD(strcpy_heap_before_end); +ATF_TC(strcpy_heap_before_end); +ATF_TC_HEAD(strcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(strcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1627,7 +1786,10 @@ } -ATF_TC_WITHOUT_HEAD(strcpy_heap_end); +ATF_TC(strcpy_heap_end); +ATF_TC_HEAD(strcpy_heap_end, tc) +{ +} ATF_TC_BODY(strcpy_heap_end, tc) { #define BUF __stack.__buf @@ -1651,7 +1813,10 @@ } -ATF_TC_WITHOUT_HEAD(strcpy_heap_after_end); +ATF_TC(strcpy_heap_after_end); +ATF_TC_HEAD(strcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(strcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -1706,7 +1871,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcpy_before_end); +ATF_TC(strlcpy_before_end); +ATF_TC_HEAD(strlcpy_before_end, tc) +{ +} ATF_TC_BODY(strlcpy_before_end, tc) { #define BUF &__stack.__buf @@ -1729,7 +1897,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcpy_end); +ATF_TC(strlcpy_end); +ATF_TC_HEAD(strlcpy_end, tc) +{ +} ATF_TC_BODY(strlcpy_end, tc) { #define BUF &__stack.__buf @@ -1752,7 +1923,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcpy_heap_before_end); +ATF_TC(strlcpy_heap_before_end); +ATF_TC_HEAD(strlcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(strlcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1776,7 +1950,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcpy_heap_end); +ATF_TC(strlcpy_heap_end); +ATF_TC_HEAD(strlcpy_heap_end, tc) +{ +} ATF_TC_BODY(strlcpy_heap_end, tc) { #define BUF __stack.__buf @@ -1800,7 +1977,10 @@ } -ATF_TC_WITHOUT_HEAD(strlcpy_heap_after_end); +ATF_TC(strlcpy_heap_after_end); +ATF_TC_HEAD(strlcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(strlcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -1855,7 +2035,10 @@ } -ATF_TC_WITHOUT_HEAD(strncpy_before_end); +ATF_TC(strncpy_before_end); +ATF_TC_HEAD(strncpy_before_end, tc) +{ +} ATF_TC_BODY(strncpy_before_end, tc) { #define BUF &__stack.__buf @@ -1878,7 +2061,10 @@ } -ATF_TC_WITHOUT_HEAD(strncpy_end); +ATF_TC(strncpy_end); +ATF_TC_HEAD(strncpy_end, tc) +{ +} ATF_TC_BODY(strncpy_end, tc) { #define BUF &__stack.__buf @@ -1901,7 +2087,10 @@ } -ATF_TC_WITHOUT_HEAD(strncpy_heap_before_end); +ATF_TC(strncpy_heap_before_end); +ATF_TC_HEAD(strncpy_heap_before_end, tc) +{ +} ATF_TC_BODY(strncpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1925,7 +2114,10 @@ } -ATF_TC_WITHOUT_HEAD(strncpy_heap_end); +ATF_TC(strncpy_heap_end); +ATF_TC_HEAD(strncpy_heap_end, tc) +{ +} ATF_TC_BODY(strncpy_heap_end, tc) { #define BUF __stack.__buf @@ -1949,7 +2141,10 @@ } -ATF_TC_WITHOUT_HEAD(strncpy_heap_after_end); +ATF_TC(strncpy_heap_after_end); +ATF_TC_HEAD(strncpy_heap_after_end, tc) +{ +} ATF_TC_BODY(strncpy_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_strings_test.c b/lib/libc/tests/secure/fortify_strings_test.c --- a/lib/libc/tests/secure/fortify_strings_test.c +++ b/lib/libc/tests/secure/fortify_strings_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(bcopy_before_end); +ATF_TC(bcopy_before_end); +ATF_TC_HEAD(bcopy_before_end, tc) +{ +} ATF_TC_BODY(bcopy_before_end, tc) { #define BUF &__stack.__buf @@ -181,7 +184,10 @@ } -ATF_TC_WITHOUT_HEAD(bcopy_end); +ATF_TC(bcopy_end); +ATF_TC_HEAD(bcopy_end, tc) +{ +} ATF_TC_BODY(bcopy_end, tc) { #define BUF &__stack.__buf @@ -200,7 +206,10 @@ } -ATF_TC_WITHOUT_HEAD(bcopy_heap_before_end); +ATF_TC(bcopy_heap_before_end); +ATF_TC_HEAD(bcopy_heap_before_end, tc) +{ +} ATF_TC_BODY(bcopy_heap_before_end, tc) { #define BUF __stack.__buf @@ -221,7 +230,10 @@ } -ATF_TC_WITHOUT_HEAD(bcopy_heap_end); +ATF_TC(bcopy_heap_end); +ATF_TC_HEAD(bcopy_heap_end, tc) +{ +} ATF_TC_BODY(bcopy_heap_end, tc) { #define BUF __stack.__buf @@ -242,7 +254,10 @@ } -ATF_TC_WITHOUT_HEAD(bcopy_heap_after_end); +ATF_TC(bcopy_heap_after_end); +ATF_TC_HEAD(bcopy_heap_after_end, tc) +{ +} ATF_TC_BODY(bcopy_heap_after_end, tc) { #define BUF __stack.__buf @@ -294,7 +309,10 @@ } -ATF_TC_WITHOUT_HEAD(bzero_before_end); +ATF_TC(bzero_before_end); +ATF_TC_HEAD(bzero_before_end, tc) +{ +} ATF_TC_BODY(bzero_before_end, tc) { #define BUF &__stack.__buf @@ -312,7 +330,10 @@ } -ATF_TC_WITHOUT_HEAD(bzero_end); +ATF_TC(bzero_end); +ATF_TC_HEAD(bzero_end, tc) +{ +} ATF_TC_BODY(bzero_end, tc) { #define BUF &__stack.__buf @@ -330,7 +351,10 @@ } -ATF_TC_WITHOUT_HEAD(bzero_heap_before_end); +ATF_TC(bzero_heap_before_end); +ATF_TC_HEAD(bzero_heap_before_end, tc) +{ +} ATF_TC_BODY(bzero_heap_before_end, tc) { #define BUF __stack.__buf @@ -350,7 +374,10 @@ } -ATF_TC_WITHOUT_HEAD(bzero_heap_end); +ATF_TC(bzero_heap_end); +ATF_TC_HEAD(bzero_heap_end, tc) +{ +} ATF_TC_BODY(bzero_heap_end, tc) { #define BUF __stack.__buf @@ -370,7 +397,10 @@ } -ATF_TC_WITHOUT_HEAD(bzero_heap_after_end); +ATF_TC(bzero_heap_after_end); +ATF_TC_HEAD(bzero_heap_after_end, tc) +{ +} ATF_TC_BODY(bzero_heap_after_end, tc) { #define BUF __stack.__buf @@ -421,7 +451,10 @@ } -ATF_TC_WITHOUT_HEAD(explicit_bzero_before_end); +ATF_TC(explicit_bzero_before_end); +ATF_TC_HEAD(explicit_bzero_before_end, tc) +{ +} ATF_TC_BODY(explicit_bzero_before_end, tc) { #define BUF &__stack.__buf @@ -439,7 +472,10 @@ } -ATF_TC_WITHOUT_HEAD(explicit_bzero_end); +ATF_TC(explicit_bzero_end); +ATF_TC_HEAD(explicit_bzero_end, tc) +{ +} ATF_TC_BODY(explicit_bzero_end, tc) { #define BUF &__stack.__buf @@ -457,7 +493,10 @@ } -ATF_TC_WITHOUT_HEAD(explicit_bzero_heap_before_end); +ATF_TC(explicit_bzero_heap_before_end); +ATF_TC_HEAD(explicit_bzero_heap_before_end, tc) +{ +} ATF_TC_BODY(explicit_bzero_heap_before_end, tc) { #define BUF __stack.__buf @@ -477,7 +516,10 @@ } -ATF_TC_WITHOUT_HEAD(explicit_bzero_heap_end); +ATF_TC(explicit_bzero_heap_end); +ATF_TC_HEAD(explicit_bzero_heap_end, tc) +{ +} ATF_TC_BODY(explicit_bzero_heap_end, tc) { #define BUF __stack.__buf @@ -497,7 +539,10 @@ } -ATF_TC_WITHOUT_HEAD(explicit_bzero_heap_after_end); +ATF_TC(explicit_bzero_heap_after_end); +ATF_TC_HEAD(explicit_bzero_heap_after_end, tc) +{ +} ATF_TC_BODY(explicit_bzero_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_uio_test.c b/lib/libc/tests/secure/fortify_uio_test.c --- a/lib/libc/tests/secure/fortify_uio_test.c +++ b/lib/libc/tests/secure/fortify_uio_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(readv_before_end); +ATF_TC(readv_before_end); +ATF_TC_HEAD(readv_before_end, tc) +{ +} ATF_TC_BODY(readv_before_end, tc) { #define BUF &__stack.__buf @@ -180,7 +183,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_end); +ATF_TC(readv_end); +ATF_TC_HEAD(readv_end, tc) +{ +} ATF_TC_BODY(readv_end, tc) { #define BUF &__stack.__buf @@ -198,7 +204,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_after_end); +ATF_TC(readv_after_end); +ATF_TC_HEAD(readv_after_end, tc) +{ +} ATF_TC_BODY(readv_after_end, tc) { #define BUF &__stack.__buf @@ -247,7 +256,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_heap_before_end); +ATF_TC(readv_heap_before_end); +ATF_TC_HEAD(readv_heap_before_end, tc) +{ +} ATF_TC_BODY(readv_heap_before_end, tc) { #define BUF __stack.__buf @@ -267,7 +279,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_heap_end); +ATF_TC(readv_heap_end); +ATF_TC_HEAD(readv_heap_end, tc) +{ +} ATF_TC_BODY(readv_heap_end, tc) { #define BUF __stack.__buf @@ -287,7 +302,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_heap_after_end); +ATF_TC(readv_heap_after_end); +ATF_TC_HEAD(readv_heap_after_end, tc) +{ +} ATF_TC_BODY(readv_heap_after_end, tc) { #define BUF __stack.__buf @@ -338,7 +356,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_iov_before_end); +ATF_TC(readv_iov_before_end); +ATF_TC_HEAD(readv_iov_before_end, tc) +{ +} ATF_TC_BODY(readv_iov_before_end, tc) { #define BUF &__stack.__buf @@ -362,7 +383,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_iov_end); +ATF_TC(readv_iov_end); +ATF_TC_HEAD(readv_iov_end, tc) +{ +} ATF_TC_BODY(readv_iov_end, tc) { #define BUF &__stack.__buf @@ -386,7 +410,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_iov_heap_before_end); +ATF_TC(readv_iov_heap_before_end); +ATF_TC_HEAD(readv_iov_heap_before_end, tc) +{ +} ATF_TC_BODY(readv_iov_heap_before_end, tc) { #define BUF __stack.__buf @@ -411,7 +438,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_iov_heap_end); +ATF_TC(readv_iov_heap_end); +ATF_TC_HEAD(readv_iov_heap_end, tc) +{ +} ATF_TC_BODY(readv_iov_heap_end, tc) { #define BUF __stack.__buf @@ -436,7 +466,10 @@ } -ATF_TC_WITHOUT_HEAD(readv_iov_heap_after_end); +ATF_TC(readv_iov_heap_after_end); +ATF_TC_HEAD(readv_iov_heap_after_end, tc) +{ +} ATF_TC_BODY(readv_iov_heap_after_end, tc) { #define BUF __stack.__buf @@ -492,7 +525,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_before_end); +ATF_TC(preadv_before_end); +ATF_TC_HEAD(preadv_before_end, tc) +{ +} ATF_TC_BODY(preadv_before_end, tc) { #define BUF &__stack.__buf @@ -510,7 +546,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_end); +ATF_TC(preadv_end); +ATF_TC_HEAD(preadv_end, tc) +{ +} ATF_TC_BODY(preadv_end, tc) { #define BUF &__stack.__buf @@ -528,7 +567,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_after_end); +ATF_TC(preadv_after_end); +ATF_TC_HEAD(preadv_after_end, tc) +{ +} ATF_TC_BODY(preadv_after_end, tc) { #define BUF &__stack.__buf @@ -577,7 +619,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_heap_before_end); +ATF_TC(preadv_heap_before_end); +ATF_TC_HEAD(preadv_heap_before_end, tc) +{ +} ATF_TC_BODY(preadv_heap_before_end, tc) { #define BUF __stack.__buf @@ -597,7 +642,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_heap_end); +ATF_TC(preadv_heap_end); +ATF_TC_HEAD(preadv_heap_end, tc) +{ +} ATF_TC_BODY(preadv_heap_end, tc) { #define BUF __stack.__buf @@ -617,7 +665,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_heap_after_end); +ATF_TC(preadv_heap_after_end); +ATF_TC_HEAD(preadv_heap_after_end, tc) +{ +} ATF_TC_BODY(preadv_heap_after_end, tc) { #define BUF __stack.__buf @@ -668,7 +719,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_iov_before_end); +ATF_TC(preadv_iov_before_end); +ATF_TC_HEAD(preadv_iov_before_end, tc) +{ +} ATF_TC_BODY(preadv_iov_before_end, tc) { #define BUF &__stack.__buf @@ -692,7 +746,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_iov_end); +ATF_TC(preadv_iov_end); +ATF_TC_HEAD(preadv_iov_end, tc) +{ +} ATF_TC_BODY(preadv_iov_end, tc) { #define BUF &__stack.__buf @@ -716,7 +773,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_iov_heap_before_end); +ATF_TC(preadv_iov_heap_before_end); +ATF_TC_HEAD(preadv_iov_heap_before_end, tc) +{ +} ATF_TC_BODY(preadv_iov_heap_before_end, tc) { #define BUF __stack.__buf @@ -741,7 +801,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_iov_heap_end); +ATF_TC(preadv_iov_heap_end); +ATF_TC_HEAD(preadv_iov_heap_end, tc) +{ +} ATF_TC_BODY(preadv_iov_heap_end, tc) { #define BUF __stack.__buf @@ -766,7 +829,10 @@ } -ATF_TC_WITHOUT_HEAD(preadv_iov_heap_after_end); +ATF_TC(preadv_iov_heap_after_end); +ATF_TC_HEAD(preadv_iov_heap_after_end, tc) +{ +} ATF_TC_BODY(preadv_iov_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_unistd_test.c b/lib/libc/tests/secure/fortify_unistd_test.c --- a/lib/libc/tests/secure/fortify_unistd_test.c +++ b/lib/libc/tests/secure/fortify_unistd_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(getcwd_before_end); +ATF_TC(getcwd_before_end); +ATF_TC_HEAD(getcwd_before_end, tc) +{ +} ATF_TC_BODY(getcwd_before_end, tc) { #define BUF &__stack.__buf @@ -180,7 +183,10 @@ } -ATF_TC_WITHOUT_HEAD(getcwd_end); +ATF_TC(getcwd_end); +ATF_TC_HEAD(getcwd_end, tc) +{ +} ATF_TC_BODY(getcwd_end, tc) { #define BUF &__stack.__buf @@ -198,7 +204,10 @@ } -ATF_TC_WITHOUT_HEAD(getcwd_heap_before_end); +ATF_TC(getcwd_heap_before_end); +ATF_TC_HEAD(getcwd_heap_before_end, tc) +{ +} ATF_TC_BODY(getcwd_heap_before_end, tc) { #define BUF __stack.__buf @@ -218,7 +227,10 @@ } -ATF_TC_WITHOUT_HEAD(getcwd_heap_end); +ATF_TC(getcwd_heap_end); +ATF_TC_HEAD(getcwd_heap_end, tc) +{ +} ATF_TC_BODY(getcwd_heap_end, tc) { #define BUF __stack.__buf @@ -238,7 +250,10 @@ } -ATF_TC_WITHOUT_HEAD(getcwd_heap_after_end); +ATF_TC(getcwd_heap_after_end); +ATF_TC_HEAD(getcwd_heap_after_end, tc) +{ +} ATF_TC_BODY(getcwd_heap_after_end, tc) { #define BUF __stack.__buf @@ -289,7 +304,10 @@ } -ATF_TC_WITHOUT_HEAD(getgrouplist_before_end); +ATF_TC(getgrouplist_before_end); +ATF_TC_HEAD(getgrouplist_before_end, tc) +{ +} ATF_TC_BODY(getgrouplist_before_end, tc) { #define BUF &__stack.__buf @@ -308,7 +326,10 @@ } -ATF_TC_WITHOUT_HEAD(getgrouplist_end); +ATF_TC(getgrouplist_end); +ATF_TC_HEAD(getgrouplist_end, tc) +{ +} ATF_TC_BODY(getgrouplist_end, tc) { #define BUF &__stack.__buf @@ -327,7 +348,10 @@ } -ATF_TC_WITHOUT_HEAD(getgrouplist_heap_before_end); +ATF_TC(getgrouplist_heap_before_end); +ATF_TC_HEAD(getgrouplist_heap_before_end, tc) +{ +} ATF_TC_BODY(getgrouplist_heap_before_end, tc) { #define BUF __stack.__buf @@ -348,7 +372,10 @@ } -ATF_TC_WITHOUT_HEAD(getgrouplist_heap_end); +ATF_TC(getgrouplist_heap_end); +ATF_TC_HEAD(getgrouplist_heap_end, tc) +{ +} ATF_TC_BODY(getgrouplist_heap_end, tc) { #define BUF __stack.__buf @@ -369,7 +396,10 @@ } -ATF_TC_WITHOUT_HEAD(getgrouplist_heap_after_end); +ATF_TC(getgrouplist_heap_after_end); +ATF_TC_HEAD(getgrouplist_heap_after_end, tc) +{ +} ATF_TC_BODY(getgrouplist_heap_after_end, tc) { #define BUF __stack.__buf @@ -421,7 +451,10 @@ } -ATF_TC_WITHOUT_HEAD(getgroups_before_end); +ATF_TC(getgroups_before_end); +ATF_TC_HEAD(getgroups_before_end, tc) +{ +} ATF_TC_BODY(getgroups_before_end, tc) { #define BUF &__stack.__buf @@ -439,7 +472,10 @@ } -ATF_TC_WITHOUT_HEAD(getgroups_end); +ATF_TC(getgroups_end); +ATF_TC_HEAD(getgroups_end, tc) +{ +} ATF_TC_BODY(getgroups_end, tc) { #define BUF &__stack.__buf @@ -457,7 +493,10 @@ } -ATF_TC_WITHOUT_HEAD(getgroups_heap_before_end); +ATF_TC(getgroups_heap_before_end); +ATF_TC_HEAD(getgroups_heap_before_end, tc) +{ +} ATF_TC_BODY(getgroups_heap_before_end, tc) { #define BUF __stack.__buf @@ -477,7 +516,10 @@ } -ATF_TC_WITHOUT_HEAD(getgroups_heap_end); +ATF_TC(getgroups_heap_end); +ATF_TC_HEAD(getgroups_heap_end, tc) +{ +} ATF_TC_BODY(getgroups_heap_end, tc) { #define BUF __stack.__buf @@ -497,7 +539,10 @@ } -ATF_TC_WITHOUT_HEAD(getgroups_heap_after_end); +ATF_TC(getgroups_heap_after_end); +ATF_TC_HEAD(getgroups_heap_after_end, tc) +{ +} ATF_TC_BODY(getgroups_heap_after_end, tc) { #define BUF __stack.__buf @@ -548,7 +593,10 @@ } -ATF_TC_WITHOUT_HEAD(getloginclass_before_end); +ATF_TC(getloginclass_before_end); +ATF_TC_HEAD(getloginclass_before_end, tc) +{ +} ATF_TC_BODY(getloginclass_before_end, tc) { #define BUF &__stack.__buf @@ -566,7 +614,10 @@ } -ATF_TC_WITHOUT_HEAD(getloginclass_end); +ATF_TC(getloginclass_end); +ATF_TC_HEAD(getloginclass_end, tc) +{ +} ATF_TC_BODY(getloginclass_end, tc) { #define BUF &__stack.__buf @@ -584,7 +635,10 @@ } -ATF_TC_WITHOUT_HEAD(getloginclass_heap_before_end); +ATF_TC(getloginclass_heap_before_end); +ATF_TC_HEAD(getloginclass_heap_before_end, tc) +{ +} ATF_TC_BODY(getloginclass_heap_before_end, tc) { #define BUF __stack.__buf @@ -604,7 +658,10 @@ } -ATF_TC_WITHOUT_HEAD(getloginclass_heap_end); +ATF_TC(getloginclass_heap_end); +ATF_TC_HEAD(getloginclass_heap_end, tc) +{ +} ATF_TC_BODY(getloginclass_heap_end, tc) { #define BUF __stack.__buf @@ -624,7 +681,10 @@ } -ATF_TC_WITHOUT_HEAD(getloginclass_heap_after_end); +ATF_TC(getloginclass_heap_after_end); +ATF_TC_HEAD(getloginclass_heap_after_end, tc) +{ +} ATF_TC_BODY(getloginclass_heap_after_end, tc) { #define BUF __stack.__buf @@ -675,7 +735,10 @@ } -ATF_TC_WITHOUT_HEAD(pread_before_end); +ATF_TC(pread_before_end); +ATF_TC_HEAD(pread_before_end, tc) +{ +} ATF_TC_BODY(pread_before_end, tc) { #define BUF &__stack.__buf @@ -696,7 +759,10 @@ } -ATF_TC_WITHOUT_HEAD(pread_end); +ATF_TC(pread_end); +ATF_TC_HEAD(pread_end, tc) +{ +} ATF_TC_BODY(pread_end, tc) { #define BUF &__stack.__buf @@ -717,7 +783,10 @@ } -ATF_TC_WITHOUT_HEAD(pread_heap_before_end); +ATF_TC(pread_heap_before_end); +ATF_TC_HEAD(pread_heap_before_end, tc) +{ +} ATF_TC_BODY(pread_heap_before_end, tc) { #define BUF __stack.__buf @@ -739,7 +808,10 @@ } -ATF_TC_WITHOUT_HEAD(pread_heap_end); +ATF_TC(pread_heap_end); +ATF_TC_HEAD(pread_heap_end, tc) +{ +} ATF_TC_BODY(pread_heap_end, tc) { #define BUF __stack.__buf @@ -761,7 +833,10 @@ } -ATF_TC_WITHOUT_HEAD(pread_heap_after_end); +ATF_TC(pread_heap_after_end); +ATF_TC_HEAD(pread_heap_after_end, tc) +{ +} ATF_TC_BODY(pread_heap_after_end, tc) { #define BUF __stack.__buf @@ -814,7 +889,10 @@ } -ATF_TC_WITHOUT_HEAD(read_before_end); +ATF_TC(read_before_end); +ATF_TC_HEAD(read_before_end, tc) +{ +} ATF_TC_BODY(read_before_end, tc) { #define BUF &__stack.__buf @@ -835,7 +913,10 @@ } -ATF_TC_WITHOUT_HEAD(read_end); +ATF_TC(read_end); +ATF_TC_HEAD(read_end, tc) +{ +} ATF_TC_BODY(read_end, tc) { #define BUF &__stack.__buf @@ -856,7 +937,10 @@ } -ATF_TC_WITHOUT_HEAD(read_heap_before_end); +ATF_TC(read_heap_before_end); +ATF_TC_HEAD(read_heap_before_end, tc) +{ +} ATF_TC_BODY(read_heap_before_end, tc) { #define BUF __stack.__buf @@ -878,7 +962,10 @@ } -ATF_TC_WITHOUT_HEAD(read_heap_end); +ATF_TC(read_heap_end); +ATF_TC_HEAD(read_heap_end, tc) +{ +} ATF_TC_BODY(read_heap_end, tc) { #define BUF __stack.__buf @@ -900,7 +987,10 @@ } -ATF_TC_WITHOUT_HEAD(read_heap_after_end); +ATF_TC(read_heap_after_end); +ATF_TC_HEAD(read_heap_after_end, tc) +{ +} ATF_TC_BODY(read_heap_after_end, tc) { #define BUF __stack.__buf @@ -953,7 +1043,10 @@ } -ATF_TC_WITHOUT_HEAD(readlink_before_end); +ATF_TC(readlink_before_end); +ATF_TC_HEAD(readlink_before_end, tc) +{ +} ATF_TC_BODY(readlink_before_end, tc) { #define BUF &__stack.__buf @@ -974,7 +1067,10 @@ } -ATF_TC_WITHOUT_HEAD(readlink_end); +ATF_TC(readlink_end); +ATF_TC_HEAD(readlink_end, tc) +{ +} ATF_TC_BODY(readlink_end, tc) { #define BUF &__stack.__buf @@ -995,7 +1091,10 @@ } -ATF_TC_WITHOUT_HEAD(readlink_heap_before_end); +ATF_TC(readlink_heap_before_end); +ATF_TC_HEAD(readlink_heap_before_end, tc) +{ +} ATF_TC_BODY(readlink_heap_before_end, tc) { #define BUF __stack.__buf @@ -1017,7 +1116,10 @@ } -ATF_TC_WITHOUT_HEAD(readlink_heap_end); +ATF_TC(readlink_heap_end); +ATF_TC_HEAD(readlink_heap_end, tc) +{ +} ATF_TC_BODY(readlink_heap_end, tc) { #define BUF __stack.__buf @@ -1039,7 +1141,10 @@ } -ATF_TC_WITHOUT_HEAD(readlink_heap_after_end); +ATF_TC(readlink_heap_after_end); +ATF_TC_HEAD(readlink_heap_after_end, tc) +{ +} ATF_TC_BODY(readlink_heap_after_end, tc) { #define BUF __stack.__buf @@ -1092,7 +1197,10 @@ } -ATF_TC_WITHOUT_HEAD(readlinkat_before_end); +ATF_TC(readlinkat_before_end); +ATF_TC_HEAD(readlinkat_before_end, tc) +{ +} ATF_TC_BODY(readlinkat_before_end, tc) { #define BUF &__stack.__buf @@ -1113,7 +1221,10 @@ } -ATF_TC_WITHOUT_HEAD(readlinkat_end); +ATF_TC(readlinkat_end); +ATF_TC_HEAD(readlinkat_end, tc) +{ +} ATF_TC_BODY(readlinkat_end, tc) { #define BUF &__stack.__buf @@ -1134,7 +1245,10 @@ } -ATF_TC_WITHOUT_HEAD(readlinkat_heap_before_end); +ATF_TC(readlinkat_heap_before_end); +ATF_TC_HEAD(readlinkat_heap_before_end, tc) +{ +} ATF_TC_BODY(readlinkat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1156,7 +1270,10 @@ } -ATF_TC_WITHOUT_HEAD(readlinkat_heap_end); +ATF_TC(readlinkat_heap_end); +ATF_TC_HEAD(readlinkat_heap_end, tc) +{ +} ATF_TC_BODY(readlinkat_heap_end, tc) { #define BUF __stack.__buf @@ -1178,7 +1295,10 @@ } -ATF_TC_WITHOUT_HEAD(readlinkat_heap_after_end); +ATF_TC(readlinkat_heap_after_end); +ATF_TC_HEAD(readlinkat_heap_after_end, tc) +{ +} ATF_TC_BODY(readlinkat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1231,7 +1351,10 @@ } -ATF_TC_WITHOUT_HEAD(getdomainname_before_end); +ATF_TC(getdomainname_before_end); +ATF_TC_HEAD(getdomainname_before_end, tc) +{ +} ATF_TC_BODY(getdomainname_before_end, tc) { #define BUF &__stack.__buf @@ -1254,7 +1377,10 @@ } -ATF_TC_WITHOUT_HEAD(getdomainname_end); +ATF_TC(getdomainname_end); +ATF_TC_HEAD(getdomainname_end, tc) +{ +} ATF_TC_BODY(getdomainname_end, tc) { #define BUF &__stack.__buf @@ -1277,7 +1403,10 @@ } -ATF_TC_WITHOUT_HEAD(getdomainname_heap_before_end); +ATF_TC(getdomainname_heap_before_end); +ATF_TC_HEAD(getdomainname_heap_before_end, tc) +{ +} ATF_TC_BODY(getdomainname_heap_before_end, tc) { #define BUF __stack.__buf @@ -1302,7 +1431,10 @@ } -ATF_TC_WITHOUT_HEAD(getdomainname_heap_end); +ATF_TC(getdomainname_heap_end); +ATF_TC_HEAD(getdomainname_heap_end, tc) +{ +} ATF_TC_BODY(getdomainname_heap_end, tc) { #define BUF __stack.__buf @@ -1327,7 +1459,10 @@ } -ATF_TC_WITHOUT_HEAD(getdomainname_heap_after_end); +ATF_TC(getdomainname_heap_after_end); +ATF_TC_HEAD(getdomainname_heap_after_end, tc) +{ +} ATF_TC_BODY(getdomainname_heap_after_end, tc) { #define BUF __stack.__buf @@ -1383,7 +1518,10 @@ } -ATF_TC_WITHOUT_HEAD(getentropy_before_end); +ATF_TC(getentropy_before_end); +ATF_TC_HEAD(getentropy_before_end, tc) +{ +} ATF_TC_BODY(getentropy_before_end, tc) { #define BUF &__stack.__buf @@ -1401,7 +1539,10 @@ } -ATF_TC_WITHOUT_HEAD(getentropy_end); +ATF_TC(getentropy_end); +ATF_TC_HEAD(getentropy_end, tc) +{ +} ATF_TC_BODY(getentropy_end, tc) { #define BUF &__stack.__buf @@ -1419,7 +1560,10 @@ } -ATF_TC_WITHOUT_HEAD(getentropy_heap_before_end); +ATF_TC(getentropy_heap_before_end); +ATF_TC_HEAD(getentropy_heap_before_end, tc) +{ +} ATF_TC_BODY(getentropy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1439,7 +1583,10 @@ } -ATF_TC_WITHOUT_HEAD(getentropy_heap_end); +ATF_TC(getentropy_heap_end); +ATF_TC_HEAD(getentropy_heap_end, tc) +{ +} ATF_TC_BODY(getentropy_heap_end, tc) { #define BUF __stack.__buf @@ -1459,7 +1606,10 @@ } -ATF_TC_WITHOUT_HEAD(getentropy_heap_after_end); +ATF_TC(getentropy_heap_after_end); +ATF_TC_HEAD(getentropy_heap_after_end, tc) +{ +} ATF_TC_BODY(getentropy_heap_after_end, tc) { #define BUF __stack.__buf @@ -1510,7 +1660,10 @@ } -ATF_TC_WITHOUT_HEAD(gethostname_before_end); +ATF_TC(gethostname_before_end); +ATF_TC_HEAD(gethostname_before_end, tc) +{ +} ATF_TC_BODY(gethostname_before_end, tc) { #define BUF &__stack.__buf @@ -1534,7 +1687,10 @@ } -ATF_TC_WITHOUT_HEAD(gethostname_end); +ATF_TC(gethostname_end); +ATF_TC_HEAD(gethostname_end, tc) +{ +} ATF_TC_BODY(gethostname_end, tc) { #define BUF &__stack.__buf @@ -1558,7 +1714,10 @@ } -ATF_TC_WITHOUT_HEAD(gethostname_heap_before_end); +ATF_TC(gethostname_heap_before_end); +ATF_TC_HEAD(gethostname_heap_before_end, tc) +{ +} ATF_TC_BODY(gethostname_heap_before_end, tc) { #define BUF __stack.__buf @@ -1584,7 +1743,10 @@ } -ATF_TC_WITHOUT_HEAD(gethostname_heap_end); +ATF_TC(gethostname_heap_end); +ATF_TC_HEAD(gethostname_heap_end, tc) +{ +} ATF_TC_BODY(gethostname_heap_end, tc) { #define BUF __stack.__buf @@ -1610,7 +1772,10 @@ } -ATF_TC_WITHOUT_HEAD(gethostname_heap_after_end); +ATF_TC(gethostname_heap_after_end); +ATF_TC_HEAD(gethostname_heap_after_end, tc) +{ +} ATF_TC_BODY(gethostname_heap_after_end, tc) { #define BUF __stack.__buf @@ -1667,7 +1832,10 @@ } -ATF_TC_WITHOUT_HEAD(getlogin_r_before_end); +ATF_TC(getlogin_r_before_end); +ATF_TC_HEAD(getlogin_r_before_end, tc) +{ +} ATF_TC_BODY(getlogin_r_before_end, tc) { #define BUF &__stack.__buf @@ -1685,7 +1853,10 @@ } -ATF_TC_WITHOUT_HEAD(getlogin_r_end); +ATF_TC(getlogin_r_end); +ATF_TC_HEAD(getlogin_r_end, tc) +{ +} ATF_TC_BODY(getlogin_r_end, tc) { #define BUF &__stack.__buf @@ -1703,7 +1874,10 @@ } -ATF_TC_WITHOUT_HEAD(getlogin_r_heap_before_end); +ATF_TC(getlogin_r_heap_before_end); +ATF_TC_HEAD(getlogin_r_heap_before_end, tc) +{ +} ATF_TC_BODY(getlogin_r_heap_before_end, tc) { #define BUF __stack.__buf @@ -1723,7 +1897,10 @@ } -ATF_TC_WITHOUT_HEAD(getlogin_r_heap_end); +ATF_TC(getlogin_r_heap_end); +ATF_TC_HEAD(getlogin_r_heap_end, tc) +{ +} ATF_TC_BODY(getlogin_r_heap_end, tc) { #define BUF __stack.__buf @@ -1743,7 +1920,10 @@ } -ATF_TC_WITHOUT_HEAD(getlogin_r_heap_after_end); +ATF_TC(getlogin_r_heap_after_end); +ATF_TC_HEAD(getlogin_r_heap_after_end, tc) +{ +} ATF_TC_BODY(getlogin_r_heap_after_end, tc) { #define BUF __stack.__buf @@ -1794,7 +1974,10 @@ } -ATF_TC_WITHOUT_HEAD(ttyname_r_before_end); +ATF_TC(ttyname_r_before_end); +ATF_TC_HEAD(ttyname_r_before_end, tc) +{ +} ATF_TC_BODY(ttyname_r_before_end, tc) { #define BUF &__stack.__buf @@ -1817,7 +2000,10 @@ } -ATF_TC_WITHOUT_HEAD(ttyname_r_end); +ATF_TC(ttyname_r_end); +ATF_TC_HEAD(ttyname_r_end, tc) +{ +} ATF_TC_BODY(ttyname_r_end, tc) { #define BUF &__stack.__buf @@ -1840,7 +2026,10 @@ } -ATF_TC_WITHOUT_HEAD(ttyname_r_heap_before_end); +ATF_TC(ttyname_r_heap_before_end); +ATF_TC_HEAD(ttyname_r_heap_before_end, tc) +{ +} ATF_TC_BODY(ttyname_r_heap_before_end, tc) { #define BUF __stack.__buf @@ -1865,7 +2054,10 @@ } -ATF_TC_WITHOUT_HEAD(ttyname_r_heap_end); +ATF_TC(ttyname_r_heap_end); +ATF_TC_HEAD(ttyname_r_heap_end, tc) +{ +} ATF_TC_BODY(ttyname_r_heap_end, tc) { #define BUF __stack.__buf @@ -1890,7 +2082,10 @@ } -ATF_TC_WITHOUT_HEAD(ttyname_r_heap_after_end); +ATF_TC(ttyname_r_heap_after_end); +ATF_TC_HEAD(ttyname_r_heap_after_end, tc) +{ +} ATF_TC_BODY(ttyname_r_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/fortify_wchar_test.c b/lib/libc/tests/secure/fortify_wchar_test.c --- a/lib/libc/tests/secure/fortify_wchar_test.c +++ b/lib/libc/tests/secure/fortify_wchar_test.c @@ -162,7 +162,10 @@ close(fd); } -ATF_TC_WITHOUT_HEAD(wmemcpy_before_end); +ATF_TC(wmemcpy_before_end); +ATF_TC_HEAD(wmemcpy_before_end, tc) +{ +} ATF_TC_BODY(wmemcpy_before_end, tc) { #define BUF &__stack.__buf @@ -181,7 +184,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemcpy_end); +ATF_TC(wmemcpy_end); +ATF_TC_HEAD(wmemcpy_end, tc) +{ +} ATF_TC_BODY(wmemcpy_end, tc) { #define BUF &__stack.__buf @@ -200,7 +206,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemcpy_heap_before_end); +ATF_TC(wmemcpy_heap_before_end); +ATF_TC_HEAD(wmemcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(wmemcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -221,7 +230,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemcpy_heap_end); +ATF_TC(wmemcpy_heap_end); +ATF_TC_HEAD(wmemcpy_heap_end, tc) +{ +} ATF_TC_BODY(wmemcpy_heap_end, tc) { #define BUF __stack.__buf @@ -242,7 +254,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemcpy_heap_after_end); +ATF_TC(wmemcpy_heap_after_end); +ATF_TC_HEAD(wmemcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(wmemcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -294,7 +309,10 @@ } -ATF_TC_WITHOUT_HEAD(wmempcpy_before_end); +ATF_TC(wmempcpy_before_end); +ATF_TC_HEAD(wmempcpy_before_end, tc) +{ +} ATF_TC_BODY(wmempcpy_before_end, tc) { #define BUF &__stack.__buf @@ -313,7 +331,10 @@ } -ATF_TC_WITHOUT_HEAD(wmempcpy_end); +ATF_TC(wmempcpy_end); +ATF_TC_HEAD(wmempcpy_end, tc) +{ +} ATF_TC_BODY(wmempcpy_end, tc) { #define BUF &__stack.__buf @@ -332,7 +353,10 @@ } -ATF_TC_WITHOUT_HEAD(wmempcpy_heap_before_end); +ATF_TC(wmempcpy_heap_before_end); +ATF_TC_HEAD(wmempcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(wmempcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -353,7 +377,10 @@ } -ATF_TC_WITHOUT_HEAD(wmempcpy_heap_end); +ATF_TC(wmempcpy_heap_end); +ATF_TC_HEAD(wmempcpy_heap_end, tc) +{ +} ATF_TC_BODY(wmempcpy_heap_end, tc) { #define BUF __stack.__buf @@ -374,7 +401,10 @@ } -ATF_TC_WITHOUT_HEAD(wmempcpy_heap_after_end); +ATF_TC(wmempcpy_heap_after_end); +ATF_TC_HEAD(wmempcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(wmempcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -426,7 +456,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemmove_before_end); +ATF_TC(wmemmove_before_end); +ATF_TC_HEAD(wmemmove_before_end, tc) +{ +} ATF_TC_BODY(wmemmove_before_end, tc) { #define BUF &__stack.__buf @@ -445,7 +478,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemmove_end); +ATF_TC(wmemmove_end); +ATF_TC_HEAD(wmemmove_end, tc) +{ +} ATF_TC_BODY(wmemmove_end, tc) { #define BUF &__stack.__buf @@ -464,7 +500,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemmove_heap_before_end); +ATF_TC(wmemmove_heap_before_end); +ATF_TC_HEAD(wmemmove_heap_before_end, tc) +{ +} ATF_TC_BODY(wmemmove_heap_before_end, tc) { #define BUF __stack.__buf @@ -485,7 +524,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemmove_heap_end); +ATF_TC(wmemmove_heap_end); +ATF_TC_HEAD(wmemmove_heap_end, tc) +{ +} ATF_TC_BODY(wmemmove_heap_end, tc) { #define BUF __stack.__buf @@ -506,7 +548,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemmove_heap_after_end); +ATF_TC(wmemmove_heap_after_end); +ATF_TC_HEAD(wmemmove_heap_after_end, tc) +{ +} ATF_TC_BODY(wmemmove_heap_after_end, tc) { #define BUF __stack.__buf @@ -558,7 +603,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemset_before_end); +ATF_TC(wmemset_before_end); +ATF_TC_HEAD(wmemset_before_end, tc) +{ +} ATF_TC_BODY(wmemset_before_end, tc) { #define BUF &__stack.__buf @@ -576,7 +624,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemset_end); +ATF_TC(wmemset_end); +ATF_TC_HEAD(wmemset_end, tc) +{ +} ATF_TC_BODY(wmemset_end, tc) { #define BUF &__stack.__buf @@ -594,7 +645,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemset_heap_before_end); +ATF_TC(wmemset_heap_before_end); +ATF_TC_HEAD(wmemset_heap_before_end, tc) +{ +} ATF_TC_BODY(wmemset_heap_before_end, tc) { #define BUF __stack.__buf @@ -614,7 +668,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemset_heap_end); +ATF_TC(wmemset_heap_end); +ATF_TC_HEAD(wmemset_heap_end, tc) +{ +} ATF_TC_BODY(wmemset_heap_end, tc) { #define BUF __stack.__buf @@ -634,7 +691,10 @@ } -ATF_TC_WITHOUT_HEAD(wmemset_heap_after_end); +ATF_TC(wmemset_heap_after_end); +ATF_TC_HEAD(wmemset_heap_after_end, tc) +{ +} ATF_TC_BODY(wmemset_heap_after_end, tc) { #define BUF __stack.__buf @@ -685,7 +745,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpcpy_before_end); +ATF_TC(wcpcpy_before_end); +ATF_TC_HEAD(wcpcpy_before_end, tc) +{ +} ATF_TC_BODY(wcpcpy_before_end, tc) { #define BUF &__stack.__buf @@ -708,7 +771,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpcpy_end); +ATF_TC(wcpcpy_end); +ATF_TC_HEAD(wcpcpy_end, tc) +{ +} ATF_TC_BODY(wcpcpy_end, tc) { #define BUF &__stack.__buf @@ -731,7 +797,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpcpy_heap_before_end); +ATF_TC(wcpcpy_heap_before_end); +ATF_TC_HEAD(wcpcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(wcpcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -755,7 +824,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpcpy_heap_end); +ATF_TC(wcpcpy_heap_end); +ATF_TC_HEAD(wcpcpy_heap_end, tc) +{ +} ATF_TC_BODY(wcpcpy_heap_end, tc) { #define BUF __stack.__buf @@ -779,7 +851,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpcpy_heap_after_end); +ATF_TC(wcpcpy_heap_after_end); +ATF_TC_HEAD(wcpcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(wcpcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -834,7 +909,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpncpy_before_end); +ATF_TC(wcpncpy_before_end); +ATF_TC_HEAD(wcpncpy_before_end, tc) +{ +} ATF_TC_BODY(wcpncpy_before_end, tc) { #define BUF &__stack.__buf @@ -857,7 +935,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpncpy_end); +ATF_TC(wcpncpy_end); +ATF_TC_HEAD(wcpncpy_end, tc) +{ +} ATF_TC_BODY(wcpncpy_end, tc) { #define BUF &__stack.__buf @@ -880,7 +961,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpncpy_heap_before_end); +ATF_TC(wcpncpy_heap_before_end); +ATF_TC_HEAD(wcpncpy_heap_before_end, tc) +{ +} ATF_TC_BODY(wcpncpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -904,7 +988,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpncpy_heap_end); +ATF_TC(wcpncpy_heap_end); +ATF_TC_HEAD(wcpncpy_heap_end, tc) +{ +} ATF_TC_BODY(wcpncpy_heap_end, tc) { #define BUF __stack.__buf @@ -928,7 +1015,10 @@ } -ATF_TC_WITHOUT_HEAD(wcpncpy_heap_after_end); +ATF_TC(wcpncpy_heap_after_end); +ATF_TC_HEAD(wcpncpy_heap_after_end, tc) +{ +} ATF_TC_BODY(wcpncpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -983,7 +1073,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscat_before_end); +ATF_TC(wcscat_before_end); +ATF_TC_HEAD(wcscat_before_end, tc) +{ +} ATF_TC_BODY(wcscat_before_end, tc) { #define BUF &__stack.__buf @@ -1006,7 +1099,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscat_end); +ATF_TC(wcscat_end); +ATF_TC_HEAD(wcscat_end, tc) +{ +} ATF_TC_BODY(wcscat_end, tc) { #define BUF &__stack.__buf @@ -1029,7 +1125,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscat_heap_before_end); +ATF_TC(wcscat_heap_before_end); +ATF_TC_HEAD(wcscat_heap_before_end, tc) +{ +} ATF_TC_BODY(wcscat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1053,7 +1152,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscat_heap_end); +ATF_TC(wcscat_heap_end); +ATF_TC_HEAD(wcscat_heap_end, tc) +{ +} ATF_TC_BODY(wcscat_heap_end, tc) { #define BUF __stack.__buf @@ -1077,7 +1179,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscat_heap_after_end); +ATF_TC(wcscat_heap_after_end); +ATF_TC_HEAD(wcscat_heap_after_end, tc) +{ +} ATF_TC_BODY(wcscat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1132,7 +1237,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcat_before_end); +ATF_TC(wcslcat_before_end); +ATF_TC_HEAD(wcslcat_before_end, tc) +{ +} ATF_TC_BODY(wcslcat_before_end, tc) { #define BUF &__stack.__buf @@ -1155,7 +1263,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcat_end); +ATF_TC(wcslcat_end); +ATF_TC_HEAD(wcslcat_end, tc) +{ +} ATF_TC_BODY(wcslcat_end, tc) { #define BUF &__stack.__buf @@ -1178,7 +1289,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcat_heap_before_end); +ATF_TC(wcslcat_heap_before_end); +ATF_TC_HEAD(wcslcat_heap_before_end, tc) +{ +} ATF_TC_BODY(wcslcat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1202,7 +1316,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcat_heap_end); +ATF_TC(wcslcat_heap_end); +ATF_TC_HEAD(wcslcat_heap_end, tc) +{ +} ATF_TC_BODY(wcslcat_heap_end, tc) { #define BUF __stack.__buf @@ -1226,7 +1343,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcat_heap_after_end); +ATF_TC(wcslcat_heap_after_end); +ATF_TC_HEAD(wcslcat_heap_after_end, tc) +{ +} ATF_TC_BODY(wcslcat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1281,7 +1401,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncat_before_end); +ATF_TC(wcsncat_before_end); +ATF_TC_HEAD(wcsncat_before_end, tc) +{ +} ATF_TC_BODY(wcsncat_before_end, tc) { #define BUF &__stack.__buf @@ -1304,7 +1427,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncat_end); +ATF_TC(wcsncat_end); +ATF_TC_HEAD(wcsncat_end, tc) +{ +} ATF_TC_BODY(wcsncat_end, tc) { #define BUF &__stack.__buf @@ -1327,7 +1453,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncat_heap_before_end); +ATF_TC(wcsncat_heap_before_end); +ATF_TC_HEAD(wcsncat_heap_before_end, tc) +{ +} ATF_TC_BODY(wcsncat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1351,7 +1480,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncat_heap_end); +ATF_TC(wcsncat_heap_end); +ATF_TC_HEAD(wcsncat_heap_end, tc) +{ +} ATF_TC_BODY(wcsncat_heap_end, tc) { #define BUF __stack.__buf @@ -1375,7 +1507,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncat_heap_after_end); +ATF_TC(wcsncat_heap_after_end); +ATF_TC_HEAD(wcsncat_heap_after_end, tc) +{ +} ATF_TC_BODY(wcsncat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1430,7 +1565,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscpy_before_end); +ATF_TC(wcscpy_before_end); +ATF_TC_HEAD(wcscpy_before_end, tc) +{ +} ATF_TC_BODY(wcscpy_before_end, tc) { #define BUF &__stack.__buf @@ -1453,7 +1591,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscpy_end); +ATF_TC(wcscpy_end); +ATF_TC_HEAD(wcscpy_end, tc) +{ +} ATF_TC_BODY(wcscpy_end, tc) { #define BUF &__stack.__buf @@ -1476,7 +1617,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscpy_heap_before_end); +ATF_TC(wcscpy_heap_before_end); +ATF_TC_HEAD(wcscpy_heap_before_end, tc) +{ +} ATF_TC_BODY(wcscpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1500,7 +1644,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscpy_heap_end); +ATF_TC(wcscpy_heap_end); +ATF_TC_HEAD(wcscpy_heap_end, tc) +{ +} ATF_TC_BODY(wcscpy_heap_end, tc) { #define BUF __stack.__buf @@ -1524,7 +1671,10 @@ } -ATF_TC_WITHOUT_HEAD(wcscpy_heap_after_end); +ATF_TC(wcscpy_heap_after_end); +ATF_TC_HEAD(wcscpy_heap_after_end, tc) +{ +} ATF_TC_BODY(wcscpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -1579,7 +1729,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcpy_before_end); +ATF_TC(wcslcpy_before_end); +ATF_TC_HEAD(wcslcpy_before_end, tc) +{ +} ATF_TC_BODY(wcslcpy_before_end, tc) { #define BUF &__stack.__buf @@ -1602,7 +1755,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcpy_end); +ATF_TC(wcslcpy_end); +ATF_TC_HEAD(wcslcpy_end, tc) +{ +} ATF_TC_BODY(wcslcpy_end, tc) { #define BUF &__stack.__buf @@ -1625,7 +1781,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcpy_heap_before_end); +ATF_TC(wcslcpy_heap_before_end); +ATF_TC_HEAD(wcslcpy_heap_before_end, tc) +{ +} ATF_TC_BODY(wcslcpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1649,7 +1808,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcpy_heap_end); +ATF_TC(wcslcpy_heap_end); +ATF_TC_HEAD(wcslcpy_heap_end, tc) +{ +} ATF_TC_BODY(wcslcpy_heap_end, tc) { #define BUF __stack.__buf @@ -1673,7 +1835,10 @@ } -ATF_TC_WITHOUT_HEAD(wcslcpy_heap_after_end); +ATF_TC(wcslcpy_heap_after_end); +ATF_TC_HEAD(wcslcpy_heap_after_end, tc) +{ +} ATF_TC_BODY(wcslcpy_heap_after_end, tc) { #define BUF __stack.__buf @@ -1728,7 +1893,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncpy_before_end); +ATF_TC(wcsncpy_before_end); +ATF_TC_HEAD(wcsncpy_before_end, tc) +{ +} ATF_TC_BODY(wcsncpy_before_end, tc) { #define BUF &__stack.__buf @@ -1751,7 +1919,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncpy_end); +ATF_TC(wcsncpy_end); +ATF_TC_HEAD(wcsncpy_end, tc) +{ +} ATF_TC_BODY(wcsncpy_end, tc) { #define BUF &__stack.__buf @@ -1774,7 +1945,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncpy_heap_before_end); +ATF_TC(wcsncpy_heap_before_end); +ATF_TC_HEAD(wcsncpy_heap_before_end, tc) +{ +} ATF_TC_BODY(wcsncpy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1798,7 +1972,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncpy_heap_end); +ATF_TC(wcsncpy_heap_end); +ATF_TC_HEAD(wcsncpy_heap_end, tc) +{ +} ATF_TC_BODY(wcsncpy_heap_end, tc) { #define BUF __stack.__buf @@ -1822,7 +1999,10 @@ } -ATF_TC_WITHOUT_HEAD(wcsncpy_heap_after_end); +ATF_TC(wcsncpy_heap_after_end); +ATF_TC_HEAD(wcsncpy_heap_after_end, tc) +{ +} ATF_TC_BODY(wcsncpy_heap_after_end, tc) { #define BUF __stack.__buf diff --git a/lib/libc/tests/secure/generate-fortify-tests.lua b/lib/libc/tests/secure/generate-fortify-tests.lua --- a/lib/libc/tests/secure/generate-fortify-tests.lua +++ b/lib/libc/tests/secure/generate-fortify-tests.lua @@ -1066,8 +1066,15 @@ }, } -local function write_test_boilerplate(fh, name, body) - fh:write("ATF_TC_WITHOUT_HEAD(" .. name .. ");\n") +local function write_test_boilerplate(fh, name, body, def) + fh:write("ATF_TC(" .. name .. ");\n") + fh:write("ATF_TC_HEAD(" .. name .. ", tc)\n") + fh:write("{\n") + if def.need_root then + fh:write(" atf_tc_set_md_var(tc, \"require.user\", \"root\");\n") + end + fh:write("}\n") + fh:write("ATF_TC_BODY(" .. name .. ", tc)\n") fh:write("{\n" .. body .. "\n}\n\n") return name @@ -1342,7 +1349,7 @@ ::skip:: body = body .. "#undef BUF\n" - return write_test_boilerplate(fh, testname, body) + return write_test_boilerplate(fh, testname, body, def) end -- main()