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