void handler(int signo)
{
printf("Caught signal\n");
printf("Test PASSED\n");
setBackTime(tpreset);
exit(PTS_PASS);
}
int main(int argc, char *argv[])
{
struct timespec tsset, tscurrent, tsreset;
int i;
int failure = 0;
/* Check that we're root...can't call clock_settime with CLOCK_REALTIME otherwise */
if(getuid() != 0)
{
printf("Run this test as ROOT, not as a Regular User\n");
return PTS_UNTESTED;
}
if (clock_gettime(CLOCK_REALTIME, &tscurrent) != 0) {
printf("clock_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
getBeforeTime(&tsreset);
for (i = 0; i < NUMINVALIDTESTS; i++) {
tsset.tv_sec = tscurrent.tv_sec;
tsset.tv_nsec = invalid_tests[i];
printf("Test %d sec %d nsec\n",
(int) tsset.tv_sec, (int) tsset.tv_nsec);
if (clock_settime(CLOCK_REALTIME, &tsset) == -1) {
if (EINVAL != errno) {
printf("errno != EINVAL\n");
failure = 1;
}
} else {
printf("clock_settime() did not return -1\n");
failure = 1;
}
}
setBackTime(tsreset);
if (failure) {
printf("At least one test FAILED -- see above\n");
return PTS_FAIL;
} else {
printf("All tests PASSED\n");
return PTS_PASS;
}
return PTS_UNRESOLVED;
}
int main(void)
{
struct sigevent ev;
struct timespec tpT0, tpT2, tpreset;
struct itimerspec its;
timer_t tid;
int delta;
int sig;
sigset_t set;
int flags = 0;
/* Check that we're root...can't call clock_settime with CLOCK_REALTIME otherwise */
if (geteuid() != 0) {
printf("Run this test as ROOT, not as a Regular User\n");
return PTS_UNTESTED;
}
/*
* set up sigevent for timer
* set up signal set for sigwait
*/
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGTOTEST;
if (sigemptyset(&set) != 0) {
perror("sigemptyset() was not successful\n");
return PTS_UNRESOLVED;
}
if (sigaddset(&set, SIGTOTEST) != 0) {
perror("sigaddset() was not successful\n");
return PTS_UNRESOLVED;
}
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
perror("sigprocmask() failed\n");
return PTS_UNRESOLVED;
}
if (clock_gettime(CLOCK_REALTIME, &tpT0) != 0) {
perror("clock_gettime() was not successful\n");
return PTS_UNRESOLVED;
}
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
flags |= TIMER_ABSTIME;
its.it_interval.tv_sec = 0;
its.it_interval.tv_nsec = 0;
its.it_value.tv_sec = tpT0.tv_sec + TIMEROFFSET;
its.it_value.tv_nsec = tpT0.tv_nsec;
if (timer_settime(tid, flags, &its, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
sleep(SLEEPTIME);
getBeforeTime(&tpreset);
if (clock_settime(CLOCK_REALTIME, &tpT0) != 0) {
perror("clock_settime() was not successful");
return PTS_UNRESOLVED;
}
if (sigwait(&set, &sig) == -1) {
perror("sigwait() was not successful\n");
return PTS_UNRESOLVED;
}
if (clock_gettime(CLOCK_REALTIME, &tpT2) != 0) {
printf("clock_gettime() was not successful\n");
return PTS_UNRESOLVED;
}
delta = tpT2.tv_sec - its.it_value.tv_sec;
// add back time waited to reset value and reset time
tpreset.tv_sec += tpT2.tv_sec - tpT0.tv_sec;
setBackTime(tpreset);
printf("delta: %d\n", delta);
if ((delta <= ACCEPTABLEDELTA) && (delta >= 0)) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("FAIL: Ended %d, not %d\n",
(int)tpT2.tv_sec, (int)its.it_value.tv_sec);
return PTS_FAIL;
}
printf("This code should not be executed.\n");
return PTS_UNRESOLVED;
}
int main(int argc, char *argv[])
{
struct sigevent ev;
struct sigaction act;
struct timespec tsclock, ts, tsleft, tsreset;
struct itimerspec its;
timer_t tid;
sigset_t set;
/* Check that we're root...can't call clock_settime with CLOCK_REALTIME otherwise */
if(getuid() != 0)
{
printf("Run this test as ROOT, not as a Regular User\n");
return PTS_UNTESTED;
}
/*
* set up sigevent for timer
* set up signal set for sigwait
* set up sigaction to catch signal
*/
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGTOTEST;
act.sa_handler=handler;
act.sa_flags=0;
if ( (sigemptyset(&set) != 0) ||
(sigemptyset(&act.sa_mask) != 0) ) {
perror("sigemptyset() was not successful\n");
return PTS_UNRESOLVED;
}
if (sigaddset(&set, SIGTOTEST) != 0) {
perror("sigaddset() was not successful\n");
return PTS_UNRESOLVED;
}
if (sigaction(SIGTOTEST, &act, 0) != 0) {
perror("sigaction() was not successful\n");
return PTS_UNRESOLVED;
}
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
its.it_interval.tv_sec = 0; its.it_interval.tv_nsec = 0;
its.it_value.tv_sec = TIMERSEC; its.it_value.tv_nsec = 0;
if (timer_settime(tid, 0, &its, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
if (clock_gettime(CLOCK_REALTIME, &tsclock) != 0) {
printf("clock_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
tsclock.tv_sec -= CLOCKOFFSET;
getBeforeTime(&tsreset);
if (clock_settime(CLOCK_REALTIME, &tsclock) != 0) {
printf("clock_settime() was not successful\n");
return PTS_UNRESOLVED;
}
ts.tv_sec=TIMERSEC+SLEEPDELTA;
ts.tv_nsec=0;
if (nanosleep(&ts, &tsleft) != -1) {
printf("nanosleep() not interrupted\n");
return PTS_FAIL;
}
if ( abs(tsleft.tv_sec-SLEEPDELTA) <= ACCEPTABLEDELTA) {
printf("Test PASSED\n");
tsreset.tv_sec += TIMERSEC;
setBackTime(tsreset);
return PTS_PASS;
} else {
printf("Timer did not last for correct amount of time\n");
printf("timer: %d != correct %d\n",
(int) ts.tv_sec- (int) tsleft.tv_sec,
TIMERSEC);
return PTS_FAIL;
}
return PTS_UNRESOLVED;
}
int main(int argc, char *argv[])
{
struct timespec tsT0, tsT1;
int pid;
/* Check that we're root...can't call clock_settime with CLOCK_REALTIME otherwise */
if (getuid() != 0) {
printf("Run this test as ROOT, not as a Regular User\n");
return PTS_UNTESTED;
}
if (clock_gettime(CLOCK_REALTIME, &tsT0) != 0) {
perror("clock_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
if ((pid = fork()) == 0) {
/* child here */
int flags = 0;
struct timespec tsT2;
tsT1.tv_sec = tsT0.tv_sec + SLEEPOFFSET;
tsT1.tv_nsec = tsT0.tv_nsec;
flags |= TIMER_ABSTIME;
if (clock_nanosleep(CLOCK_REALTIME, flags, &tsT1, NULL) != 0) {
printf("clock_nanosleep() did not return success\n");
return CHILDFAIL;
}
if (clock_gettime(CLOCK_REALTIME, &tsT2) != 0) {
perror("clock_gettime() did not return success\n");
return CHILDFAIL;
}
if (tsT2.tv_sec >= tsT1.tv_sec) {
if ((tsT2.tv_sec - tsT1.tv_sec) <= ACCEPTABLEDELTA) {
return CHILDPASS;
} else {
printf("Ended too late. %d >> %d\n",
(int)tsT2.tv_sec, (int)tsT1.tv_sec);
return CHILDFAIL;
}
} else {
printf("Did not sleep for long enough %d < %d\n",
(int)tsT2.tv_sec, (int)tsT1.tv_sec);
return CHILDFAIL;
}
return CHILDFAIL;
} else {
/* parent here */
int i;
struct timespec tsreset;
sleep(SMALLTIME);
if (clock_settime(CLOCK_REALTIME, &tsT0) != 0) {
printf("clock_settime() did not return success\n");
return PTS_UNRESOLVED;
}
if (wait(&i) == -1) {
perror("Error waiting for child to exit\n");
return PTS_UNRESOLVED;
}
getBeforeTime(&tsreset); // get current time
tsreset.tv_sec += SMALLTIME;
setBackTime(tsreset);
if (WIFEXITED(i) && WEXITSTATUS(i)) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Test FAILED\n");
return PTS_FAIL;
}
}
return PTS_UNRESOLVED;
}
int main(int argc, char *argv[])
{
struct sigevent ev;
struct sigaction act;
struct timespec tpT0, tpclock, tsreset;
struct itimerspec its;
timer_t tid;
int i, flags = 0, nocaught = 0;
/*
* set up sigevent for timer
* set up sigaction to catch signal
*/
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGTOTEST;
act.sa_handler=handler;
act.sa_flags=0;
if (sigemptyset(&act.sa_mask) != 0) {
perror("sigemptyset() was not successful\n");
return PTS_UNRESOLVED;
}
if (sigaction(SIGTOTEST, &act, 0) != 0) {
perror("sigaction() was not successful\n");
return PTS_UNRESOLVED;
}
if (clock_gettime(CLOCK_REALTIME, &tpT0) != 0) {
perror("clock_gettime() was not successful\n");
return PTS_UNRESOLVED;
}
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
flags |= TIMER_ABSTIME;
its.it_interval.tv_sec = TIMERINTERVAL;
its.it_interval.tv_nsec = 0;
its.it_value.tv_sec = tpT0.tv_sec + TIMERINTERVAL;
its.it_value.tv_nsec = tpT0.tv_nsec;
if (timer_settime(tid, flags, &its, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
sleep(TIMERINTERVAL);
for (i = 0; i < ADDITIONALEXPIRES; i++) {
sleep(TIMERINTERVAL);
}
tpclock.tv_sec = tpT0.tv_sec;
tpclock.tv_nsec = tpT0.tv_nsec;
getBeforeTime(&tsreset);
if (clock_settime(CLOCK_REALTIME, &tpclock) != 0) {
printf("clock_settime() was not successful\n");
return PTS_UNRESOLVED;
}
caught = 0;
sleep(TIMERINTERVAL+ADDITIONALDELTA);
if (caught == 1) {
printf("Caught the first signal\n");
} else {
printf("FAIL: Didn't catch timer after TIMERINTERVAL.\n");
nocaught = 1;
}
sleep(TIMERINTERVAL+ADDITIONALDELTA);
if (caught >= 2) {
printf("Caught another signal\n");
} else {
printf("Caught %d < 2 signals\n", caught);
nocaught = 1;
}
if (nocaught) {
printf("Implementation does not repeat signals on clock reset\n");
} else {
printf("Implementation does repeat signals on clock reset\n");
}
// If we finish, pass
tsreset.tv_sec += 2*(TIMERINTERVAL+ADDITIONALDELTA);
setBackTime(tsreset);
return PTS_PASS;
}
int main(void)
{
struct sigevent ev;
struct sigaction act;
struct timespec tpT0, tpclock;
struct itimerspec its;
timer_t tid;
int flags = 0;
/*
* set up sigevent for timer
* set up sigaction to catch signal
*/
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGTOTEST;
act.sa_handler = handler;
act.sa_flags = 0;
if (sigemptyset(&act.sa_mask) != 0) {
perror("sigemptyset() was not successful\n");
return PTS_UNRESOLVED;
}
if (sigaction(SIGTOTEST, &act, 0) != 0) {
perror("sigaction() was not successful\n");
return PTS_UNRESOLVED;
}
if (clock_gettime(CLOCK_REALTIME, &tpT0) != 0) {
perror("clock_gettime() was not successful\n");
return PTS_UNRESOLVED;
}
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
flags |= TIMER_ABSTIME;
its.it_interval.tv_sec = 0;
its.it_interval.tv_nsec = 0;
its.it_value.tv_sec = tpT0.tv_sec + TIMEROFFSET;
its.it_value.tv_nsec = tpT0.tv_nsec;
if (timer_settime(tid, flags, &its, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
tpclock.tv_sec = its.it_value.tv_sec + CLOCKOFFSET;
tpclock.tv_nsec = its.it_value.tv_nsec;
getBeforeTime(&tpreset);
if (clock_settime(CLOCK_REALTIME, &tpclock) != 0) {
printf("clock_settime() was not successful\n");
return PTS_UNRESOLVED;
}
sleep(SHORTTIME);
printf("timer should have expired _immediately_\n");
tpreset.tv_sec += SHORTTIME;
setBackTime(tpreset);
return PTS_FAIL;
}
int main(int argc, char *argv[])
{
struct sigevent ev;
struct sigaction act;
struct timespec tpT0, tpclock, tpreset;
struct itimerspec its;
timer_t tid;
int flags = 0, overruns;
/*
* set up sigevent for timer
* set up sigaction to catch signal
*/
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGTOTEST;
act.sa_handler=handler;
act.sa_flags=0;
if (sigemptyset(&act.sa_mask) != 0) {
perror("sigemptyset() was not successful\n");
return PTS_UNRESOLVED;
}
if (sigaction(SIGTOTEST, &act, 0) != 0) {
perror("sigaction() was not successful\n");
return PTS_UNRESOLVED;
}
if (clock_gettime(CLOCK_REALTIME, &tpT0) != 0) {
perror("clock_gettime() was not successful\n");
return PTS_UNRESOLVED;
}
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
flags |= TIMER_ABSTIME;
its.it_interval.tv_sec = TIMERINTERVAL;
its.it_interval.tv_nsec = 0;
its.it_value.tv_sec = tpT0.tv_sec + TIMEROFFSET;
its.it_value.tv_nsec = tpT0.tv_nsec;
if (timer_settime(tid, flags, &its, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
tpclock.tv_sec = its.it_value.tv_sec + EXPECTEDOVERRUNS*TIMERINTERVAL;
tpclock.tv_nsec = its.it_value.tv_nsec;
getBeforeTime(&tpreset);
if (clock_settime(CLOCK_REALTIME, &tpclock) != 0) {
printf("clock_settime() was not successful\n");
return PTS_UNRESOLVED;
}
sleep(SHORTTIME);
overruns = timer_getoverrun(tid);
if (overruns == EXPECTEDOVERRUNS) {
printf("Overrun count == # of repeating timer expirys\n");
} else {
printf("Overrun count =%d, not # of repeating timer expirys\n",
overruns);
}
tpreset.tv_sec += SHORTTIME;
setBackTime(tpreset);
if (caught == 1) {
printf("Caught the correct number of signals\n");
} else {
printf("FAIL: Caught %d signals, not 1\n", caught);
printf("Test FAILED\n");
return PTS_FAIL;
}
printf("Test PASSED\n");
return PTS_PASS;
}
