int main(int ac, char **av)
{
int lc;
const char *msg;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
tst_count = 0;
/*
* Call unlinkat
*/
for (i = 0; i < TST_TOTAL; i++) {
TEST(myunlinkat(fds[i], filenames[i], flags[i]));
if (TEST_ERRNO == expected_errno[i]) {
tst_resm(TPASS,
"unlinkat() returned the expected errno %d: %s",
TEST_ERRNO, strerror(TEST_ERRNO));
} else {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
"unlinkat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
}
int main(int ac, char **av)
{
int lc;
char *msg;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_brkm(TCONF, NULL,
"This test can only run on kernels that are 2.6.16 and higher");
}
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
Tst_count = 0;
/*
* Call renameat
*/
for (i = 0; i < TST_TOTAL; i++) {
TEST(myrenameat
(oldfds[i], oldfilenames[i], newfds[i],
newfilenames[i]));
/* check return code */
if (TEST_ERRNO == expected_errno[i]) {
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS | TTERRNO,
"renameat failed as expected");
}
} else {
tst_resm(TFAIL | TTERRNO,
"renameat failed unexpectedly");
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
const char *msg;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* Call symlinkat
*/
for (i = 0; i < TST_TOTAL; i++) {
setup_every_copy();
mysymlinkat_test(&test_desc[i]);
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
}
int main(int ac, char **av)
{
int lc;
const char *msg;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if (((tst_kvercmp(2, 6, 16)) < 0)) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
tst_count = 0;
/*
* Call faccessat
*/
for (i = 0; i < TST_TOTAL; i++) {
TEST(myfaccessat(fds[i], filenames[i], R_OK));
/* check return code */
if (TEST_ERRNO == expected_errno[i]) {
tst_resm(TPASS,
"faccessat() returned the expected errno %d: %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
} else {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
"faccessdat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
gettimeofday(×[0], NULL);
gettimeofday(×[1], NULL);
TEST(myfutimesat(fds[i], filenames[i], times));
if (TEST_ERRNO == expected_errno[i]) {
tst_resm(TPASS,
"futimesat() returned the expected errno %d: %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
} else {
tst_resm(TFAIL,
"futimesat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc; /* loop counter */
char *msg; /* message returned from parse_opts */
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
Tst_count = 0;
/*
* Call openat
*/
for (i = 0; i < TST_TOTAL; i++) {
TEST(myopenat
(fds[i], filenames[i], O_CREAT | O_WRONLY, 0600));
/* check return code */
if (TEST_ERRNO == expected_errno[i]) {
/***************************************************************
* only perform functional verification if flag set (-f not given)
***************************************************************/
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS,
"openat() returned the expected errno %d: %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
}
} else {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
"openat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
}
int main(int ac, char **av)
{
int lc;
char *msg;
/* Disable test if the version of the kernel is less than 2.6.17 */
if ((tst_kvercmp(2, 6, 17)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.17 and higher");
exit(0);
}
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
tst_count = 0;
/*
* Call vmsplice_test
*/
TEST(vmsplice_test());
/* check return code */
if (TEST_RETURN < 0) {
if (TEST_RETURN != -1) {
TEST_ERRNO = -TEST_RETURN;
}
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL, "vmsplice() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
} else {
/***************************************************************
* only perform functional verification if flag set (-f not given)
***************************************************************/
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS, "vmsplice() returned %ld",
TEST_RETURN);
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
}
int main(int ac, char **av)
{
int lc;
char *msg;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
tst_count = 0;
/*
* Call futimesat
*/
for (i = 0; i < TST_TOTAL; i++) {
gettimeofday(×[0], NULL);
gettimeofday(×[1], NULL);
s2e_enable_forking();
s2e_make_symbolic(&fds[i], sizeof(int), "fds[i]");
s2e_make_symbolic(filenames[i], 10, "filenames");
s2e_make_symbolic(times, sizeof(struct timeval) * 2, "times");
TEST(myfutimesat(fds[i], filenames[i], times));
s2e_disable_forking();
s2e_kill_state(0, "program done");
/* check return code */
if (TEST_ERRNO == expected_errno[i]) {
/***************************************************************
* only perform functional verification if flag set (-f not given)
***************************************************************/
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS,
"futimesat() returned the expected errno %d: %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
}
} else {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
"futimesat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
}
int main(int ac, char **av)
{
int lc; /* loop counter */
char *msg; /* message returned from parse_opts */
int i;
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *)NULL)
tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
/* reset Tst_count in case we are looping. */
Tst_count = 0;
/*
* Call mkdirnat
*/
for (i = 0; i < TST_TOTAL; i++) {
TEST(mymkdirat(fds[i], dirnames[i], 0600));
/* check return code */
if (TEST_ERRNO == expected_errno[i]) {
/***************************************************************
* only perform functional verification if flag set (-f not given)
***************************************************************/
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS,
"mkdirat() returned the expected errno %d: %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
}
} else {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
"mkdirat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
} /* End for TEST_LOOPING */
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
} /* End main */
int main(int ac, char **av)
{
int lc;
char *msg;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
tst_count = 0;
/*
* Call readlinkat
*/
for (i = 0; i < TST_TOTAL; i++) {
buffer[0] = '\0';
TEST(myreadlinkat
(fds[i], filenames[i], buffer, BUFF_SIZE));
if (TEST_RETURN >= 0) {
buffer[TEST_RETURN] = '\0';
}
/* check return code */
if (TEST_ERRNO == expected_errno[i]
&& (strcmp(expected_buff[i], buffer) == 0)) {
/***************************************************************
* only perform functional verification if flag set (-f not given)
***************************************************************/
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS,
"readlinkat() returned the expected errno %d: %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
}
} else {
if (TEST_RETURN >= 0) {
tst_resm(TINFO,
"The link readlinkat got isn't as same as the expected");
}
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
"readlinkat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
}
