sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

testing: ostest: nxstyle fixes

Browse Source 
Fixes for errors reported by nxstyle tool

Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
This commit is contained in:
Alin Jerpelea 2021-06-10 11:56:16 +02:00 committed by Xiang Xiao
parent 590307e957
commit 3378b8ef54
17 changed files with 596 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
testing/mm/mm_main.c
View File

@ -59,18 +59,18 @@
static const int g_alloc_sizes[NTEST_ALLOCS] =
{
1024, 12, 962, 5692, 10254, 111, 9932, 601,
1024, 12, 962, 5692, 10254, 111, 9932, 601,
222, 2746, 3, 124321, 68, 776, 6750, 852,
4732, 28, 901, 480, 5011, 1536, 2011, 81647,
4732, 28, 901, 480, 5011, 1536, 2011, 81647,
646, 1646, 69179, 194, 2590, 7, 969, 70
};
static const int g_realloc_sizes[NTEST_ALLOCS] =
{
18, 3088, 963, 123, 511, 11666, 3723, 42,
9374, 1990, 1412, 6, 592, 4088, 11, 5040,
8663, 91255, 28, 4346, 9172, 168, 229, 4734,
59139, 221, 7830, 30421, 1666, 4, 812, 416
18, 3088, 963, 123, 511, 11666, 3723, 42,
9374, 1990, 1412, 6, 592, 4088, 11, 5040,
8663, 91255, 28, 4346, 9172, 168, 229, 4734,
59139, 221, 7830, 30421, 1666, 4, 812, 416
};
static const int g_random1[NTEST_ALLOCS] =
@ -151,7 +151,8 @@ static void do_mallocs(FAR void **mem, FAR const int *size,
if (allocsize > g_alloc_info.mxordblk)
{
fprintf(stderr, " Normal, largest free block is only %lu\n",
fprintf(stderr,
" Normal, largest free block is only %lu\n",
(unsigned long)g_alloc_info.mxordblk);
}
else
@ -190,7 +191,8 @@ static void do_reallocs(FAR void **mem, FAR const int *oldsize,
{
int allocsize = MM_ALIGN_UP(newsize[j] + SIZEOF_MM_ALLOCNODE);
fprintf(stderr, "(%d)realloc failed for allocsize=%d\n", i, allocsize);
fprintf(stderr,
"(%d)realloc failed for allocsize=%d\n", i, allocsize);
if (allocsize > g_alloc_info.mxordblk)
{
fprintf(stderr, " Normal, largest free block is only %lu\n",
@ -212,7 +214,9 @@ static void do_reallocs(FAR void **mem, FAR const int *oldsize,
}
}
static void do_memaligns(FAR void **mem, FAR const int *size, FAR const int *align,
static void do_memaligns(FAR void **mem,
FAR const int *size,
FAR const int *align,
FAR const int *seq, int n)
{
int i;
@ -229,9 +233,11 @@ static void do_memaligns(FAR void **mem, FAR const int *size, FAR const int *ali
if (mem[j] == NULL)
{
int allocsize = MM_ALIGN_UP(size[j] + SIZEOF_MM_ALLOCNODE) + 2*align[i];
int allocsize = MM_ALIGN_UP(size[j] + SIZEOF_MM_ALLOCNODE) +
2 * align[i];
fprintf(stderr, "(%d)memalign failed for allocsize=%d\n", i, allocsize);
fprintf(stderr,
"(%d)memalign failed for allocsize=%d\n", i, allocsize);
if (allocsize > g_alloc_info.mxordblk)
{
fprintf(stderr, " Normal, largest free block is only %lu\n",
@ -291,7 +297,8 @@ int main(int argc, FAR char *argv[])
/* Re-allocate the memory */
do_reallocs(g_allocs, g_alloc_sizes, g_realloc_sizes, g_random2, NTEST_ALLOCS);
do_reallocs(g_allocs, g_alloc_sizes,
g_realloc_sizes, g_random2, NTEST_ALLOCS);
/* Release the memory */
@ -299,8 +306,10 @@ int main(int argc, FAR char *argv[])
/* Allocate aligned memory */
do_memaligns(g_allocs, g_alloc_sizes, g_alignment, g_random2, NTEST_ALLOCS / 2);
do_memaligns(g_allocs, g_alloc_sizes, g_alignment, &g_random2[NTEST_ALLOCS / 2],
do_memaligns(g_allocs, g_alloc_sizes,
g_alignment, g_random2, NTEST_ALLOCS / 2);
do_memaligns(g_allocs, g_alloc_sizes,
g_alignment, &g_random2[NTEST_ALLOCS / 2],
NTEST_ALLOCS / 2);
/* Release aligned memory */

82
testing/ostest/aio.c
View File

@ -53,6 +53,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Constant write buffers */
static const char g_wrbuffer1[] = "This is write buffer #1\n";
@ -61,8 +62,7 @@ static char g_rdbuffer[AIO_RDBUFFER_SIZE];
/* AIO control blocks: write, nop, write, NULL, read */
static struct aiocb g_aiocbs[AIO_NCTRLBLKS-1];
static struct aiocb g_aiocbs[AIO_NCTRLBLKS - 1];
static struct aiocb *g_aiocb[AIO_NCTRLBLKS];
static struct aiocb * const g_aiocb_init[AIO_NCTRLBLKS] =
@ -70,7 +70,6 @@ static struct aiocb * const g_aiocb_init[AIO_NCTRLBLKS] =
&g_aiocbs[0], &g_aiocbs[1], &g_aiocbs[2], NULL, &g_aiocbs[3]
};
static FAR void * const g_buffers[AIO_NCTRLBLKS] =
{
(FAR void *)g_wrbuffer1,
@ -110,7 +109,7 @@ static void init_aiocb(bool signal)
FAR struct aiocb *aiocbp;
int i;
memset(g_aiocbs, 0xff, (AIO_NCTRLBLKS-1)*sizeof(struct aiocb));
memset(g_aiocbs, 0xff, (AIO_NCTRLBLKS - 1) * sizeof(struct aiocb));
memset(g_rdbuffer, 0xff, AIO_RDBUFFER_SIZE);
for (i = 0; i < AIO_NCTRLBLKS; i++)
@ -120,7 +119,8 @@ static void init_aiocb(bool signal)
if (aiocbp)
{
aiocbp->aio_sigevent.sigev_notify = signal ? SIGEV_SIGNAL : SIGEV_NONE;
aiocbp->aio_sigevent.sigev_notify =
signal ? SIGEV_SIGNAL : SIGEV_NONE;
aiocbp->aio_sigevent.sigev_signo = SIGUSR1;
#ifdef CONFIG_SIG_EVTHREAD
aiocbp->aio_sigevent.sigev_notify_function = NULL;
@ -133,7 +133,7 @@ static void init_aiocb(bool signal)
aiocbp->aio_fildes = g_fildes;
aiocbp->aio_reqprio = 0;
aiocbp->aio_lio_opcode = g_opcode[i];
}
}
}
}
@ -294,10 +294,11 @@ void aio_test(void)
/* Case 1: Poll for transfer complete */
printf("AIO test case 1: Poll for transfer complete\n");
g_fildes = open(AIO_FILEPATH, O_RDWR|O_CREAT|O_TRUNC);
g_fildes = open(AIO_FILEPATH, O_RDWR | O_CREAT | O_TRUNC);
if (g_fildes < 0)
{
printf("aio_test: ERROR: Failed to open %s: %d\n", AIO_FILEPATH, errno);
printf("aio_test: ERROR: Failed to open %s: %d\n",
AIO_FILEPATH, errno);
goto errout_with_procmask;
}
@ -311,7 +312,7 @@ void aio_test(void)
do
{
usleep(500*1000);
usleep(500 * 1000);
ret = check_done();
}
while (ret < 0);
@ -325,13 +326,14 @@ void aio_test(void)
* task end of the last test case -- especially the dangling SIGPOLL.
*/
usleep(500*1000);
usleep(500 * 1000);
printf("AIO test case 2: Use LIO_WAIT for transfer complete\n");
g_fildes = open(AIO_FILEPATH, O_RDWR|O_CREAT|O_TRUNC);
g_fildes = open(AIO_FILEPATH, O_RDWR | O_CREAT | O_TRUNC);
if (g_fildes < 0)
{
printf("aio_test: ERROR: Failed to open %s: %d\n", AIO_FILEPATH, errno);
printf("aio_test: ERROR: Failed to open %s: %d\n",
AIO_FILEPATH, errno);
goto errout_with_procmask;
}
@ -359,13 +361,14 @@ void aio_test(void)
* task end of the last test case -- especially the dangling SIGPOLL.
*/
usleep(500*1000);
usleep(500 * 1000);
printf("AIO test case 3: Use aio_suspend for transfer complete\n");
g_fildes = open(AIO_FILEPATH, O_RDWR|O_CREAT|O_TRUNC);
g_fildes = open(AIO_FILEPATH, O_RDWR | O_CREAT | O_TRUNC);
if (g_fildes < 0)
{
printf("aio_test: ERROR: Failed to open %s: %d\n", AIO_FILEPATH, errno);
printf("aio_test: ERROR: Failed to open %s: %d\n",
AIO_FILEPATH, errno);
goto errout_with_procmask;
}
@ -381,7 +384,8 @@ void aio_test(void)
for (i = 1; i <= AIO_NCTRLBLKS; i++)
{
printf(" Calling aio_suspend #%d\n", i);
ret = aio_suspend((FAR const struct aiocb *const *)g_aiocb, AIO_NCTRLBLKS, NULL);
ret = aio_suspend((FAR const struct aiocb *const *)g_aiocb,
AIO_NCTRLBLKS, NULL);
if (ret < 0)
{
printf("aio_test: ERROR: aio_suspend failed: %d\n", errno);
@ -406,7 +410,8 @@ void aio_test(void)
if (total != AIO_NCTRLBLKS)
{
printf("aio_test: ERROR: Total is %d, should be %d\n", total, AIO_NCTRLBLKS);
printf("aio_test: ERROR: Total is %d, should be %d\n",
total, AIO_NCTRLBLKS);
goto errout_with_fildes;
}
@ -419,13 +424,14 @@ void aio_test(void)
* task end of the last test case -- especially the dangling SIGPOLL.
*/
usleep(500*1000);
usleep(500 * 1000);
printf("AIO test case 4: Use individual signals for transfer complete\n");
g_fildes = open(AIO_FILEPATH, O_RDWR|O_CREAT|O_TRUNC);
g_fildes = open(AIO_FILEPATH, O_RDWR | O_CREAT | O_TRUNC);
if (g_fildes < 0)
{
printf("aio_test: ERROR: Failed to open %s: %d\n", AIO_FILEPATH, errno);
printf("aio_test: ERROR: Failed to open %s: %d\n",
AIO_FILEPATH, errno);
goto errout_with_procmask;
}
@ -456,7 +462,8 @@ void aio_test(void)
}
else
{
printf("aio_test: ERROR: sigwaitinfo failed: %d\n", errcode);
printf("aio_test: ERROR: sigwaitinfo failed: %d\n",
errcode);
goto errout_with_fildes;
}
}
@ -477,13 +484,15 @@ void aio_test(void)
* task end of the last test case -- especially the dangling SIGPOLL.
*/
usleep(500*1000);
usleep(500 * 1000);
printf("AIO test case 5: Use list complete signal for transfer complete\n");
g_fildes = open(AIO_FILEPATH, O_RDWR|O_CREAT|O_TRUNC);
printf("AIO test case 5:"
" Use list complete signal for transfer complete\n");
g_fildes = open(AIO_FILEPATH, O_RDWR | O_CREAT | O_TRUNC);
if (g_fildes < 0)
{
printf("aio_test: ERROR: Failed to open %s: %d\n", AIO_FILEPATH, errno);
printf("aio_test: ERROR: Failed to open %s: %d\n",
AIO_FILEPATH, errno);
goto errout_with_procmask;
}
@ -518,10 +527,11 @@ void aio_test(void)
}
else
{
printf("aio_test: ERROR: sigwaitinfo failed: %d\n", errcode);
printf("aio_test: ERROR: sigwaitinfo failed: %d\n",
errcode);
goto errout_with_fildes;
}
}
}
}
}
while (ret < 0);
@ -535,13 +545,14 @@ void aio_test(void)
* task end of the last test case -- especially the dangling SIGPOLL.
*/
usleep(500*1000);
usleep(500 * 1000);
printf("AIO test case 6: Cancel I/O by AIO control block\n");
g_fildes = open(AIO_FILEPATH, O_RDWR|O_CREAT|O_TRUNC);
g_fildes = open(AIO_FILEPATH, O_RDWR | O_CREAT | O_TRUNC);
if (g_fildes < 0)
{
printf("aio_test: ERROR: Failed to open %s: %d\n", AIO_FILEPATH, errno);
printf("aio_test: ERROR: Failed to open %s: %d\n",
AIO_FILEPATH, errno);
goto errout_with_procmask;
}
@ -564,7 +575,7 @@ void aio_test(void)
do
{
usleep(500*1000);
usleep(500 * 1000);
ret = check_done();
}
while (ret < 0);
@ -578,13 +589,14 @@ void aio_test(void)
* task end of the last test case -- especially the dangling SIGPOLL.
*/
usleep(500*1000);
usleep(500 * 1000);
printf("AIO test case 7:Cancel I/O by file descriptor\n");
g_fildes = open(AIO_FILEPATH, O_RDWR|O_CREAT|O_TRUNC);
g_fildes = open(AIO_FILEPATH, O_RDWR | O_CREAT | O_TRUNC);
if (g_fildes < 0)
{
printf("aio_test: ERROR: Failed to open %s: %d\n", AIO_FILEPATH, errno);
printf("aio_test: ERROR: Failed to open %s: %d\n",
AIO_FILEPATH, errno);
goto errout_with_procmask;
}
@ -607,7 +619,7 @@ void aio_test(void)
do
{
usleep(500*1000);
usleep(500 * 1000);
ret = check_done();
}
while (ret < 0);

160
testing/ostest/cancel.c
View File

@ -69,7 +69,7 @@ static FAR void *sem_waiter(FAR void *parameter)
for (i = 0; i < CONFIG_PTHREAD_CLEANUP_STACKSIZE ; i++)
{
pthread_cleanup_push(sem_cleaner, (FAR void *)((uintptr_t)(i+1)));
pthread_cleanup_push(sem_cleaner, (FAR void *)((uintptr_t)(i + 1)));
}
#endif
@ -79,7 +79,8 @@ static FAR void *sem_waiter(FAR void *parameter)
status = pthread_mutex_lock(&mutex);
if (status != 0)
{
printf("sem_waiter: ERROR pthread_mutex_lock failed, status=%d\n", status);
printf("sem_waiter: ERROR pthread_mutex_lock failed, status=%d\n",
status);
}
printf("sem_waiter: Starting wait for condition\n");
@ -92,7 +93,9 @@ static FAR void *sem_waiter(FAR void *parameter)
status = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
if (status != 0)
{
printf("sem_waiter: ERROR pthread_setcancelstate failed, status=%d\n", status);
printf("sem_waiter: "
"ERROR pthread_setcancelstate failed, status=%d\n",
status);
}
}
@ -103,7 +106,8 @@ static FAR void *sem_waiter(FAR void *parameter)
status = pthread_cond_wait(&cond, &mutex);
if (status != 0)
{
printf("sem_waiter: ERROR pthread_cond_wait failed, status=%d\n", status);
printf("sem_waiter: ERROR pthread_cond_wait failed, status=%d\n",
status);
}
if (!parameter)
@ -114,7 +118,9 @@ static FAR void *sem_waiter(FAR void *parameter)
status = pthread_mutex_unlock(&mutex);
if (status != 0)
{
printf("sem_waiter: ERROR pthread_mutex_unlock failed, status=%d\n", status);
printf("sem_waiter: "
"ERROR pthread_mutex_unlock failed, status=%d\n",
status);
}
/* Set the cancelable state */
@ -123,12 +129,14 @@ static FAR void *sem_waiter(FAR void *parameter)
status = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
if (status != 0)
{
printf("sem_waiter: ERROR pthread_setcancelstate failed, status=%d\n", status);
printf("sem_waiter: "
"ERROR pthread_setcancelstate failed, status=%d\n", status);
}
}
else
{
printf("sem_waiter: ERROR pthread_cond_wait returned after being cancelled!\n");
printf("sem_waiter: "
"ERROR pthread_cond_wait returned after being cancelled!\n");
}
/* Why is this here? Because pthread_setcancelstate() is not a
@ -180,7 +188,7 @@ static FAR void *mqueue_waiter(FAR void *parameter)
attr.mq_msgsize = CONFIG_MQ_MAXMSGSIZE;
attr.mq_flags = 0;
mqcancel = mq_open("mqcancel", O_RDONLY|O_CREAT, 0666, &attr);
mqcancel = mq_open("mqcancel", O_RDONLY | O_CREAT, 0666, &attr);
if (mqcancel < 0)
{
printf("mqueue_waiter: ERROR mq_open failed\n");
@ -196,9 +204,9 @@ static FAR void *mqueue_waiter(FAR void *parameter)
printf("mqueue_waiter: Awakened with %d\n", (int)nbytes);
if (mq_close(mqcancel) < 0)
{
printf("mqueue_waiter: ERROR mq_close failed\n");
}
{
printf("mqueue_waiter: ERROR mq_close failed\n");
}
printf("mqueue_waiter: Exit with status 0x12345678\n");
pthread_exit((pthread_addr_t)0x12345678);
@ -239,7 +247,8 @@ static FAR void *asynch_waiter(FAR void *parameter)
for (i = 0; i < CONFIG_PTHREAD_CLEANUP_STACKSIZE ; i++)
{
pthread_cleanup_push(sem_cleaner, (FAR void *)((uintptr_t)(i+1)));
pthread_cleanup_push(sem_cleaner,
(FAR void *)((uintptr_t)(i + 1)));
}
#endif
@ -249,7 +258,9 @@ static FAR void *asynch_waiter(FAR void *parameter)
status = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
if (status != 0)
{
printf("asynch_waiter: ERROR pthread_setcancelstate failed, status=%d\n", status);
printf("asynch_waiter: "
"ERROR pthread_setcancelstate failed, status=%d\n",
status);
}
/* Set the asynchronous cancellation type */
@ -258,14 +269,16 @@ static FAR void *asynch_waiter(FAR void *parameter)
status = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
if (status != 0)
{
printf("asynch_waiter: ERROR pthread_setcanceltype failed, status=%d\n", status);
printf("asynch_waiter: "
"ERROR pthread_setcanceltype failed, status=%d\n",
status);
}
/* Then wait a bit. We should be canceled aynchronously while waiting, but the
* cancellation should pend because we are non-cancellable.
/* Then wait a bit. We should be canceled aynchronously while waiting, but
* the cancellation should pend because we are non-cancellable.
*/
usleep(250*1000);
usleep(250 * 1000);
/* We should be canceled when restore the cancelable state. */
@ -278,7 +291,8 @@ static FAR void *asynch_waiter(FAR void *parameter)
if (status != 0)
{
printf("asynch_waiter: ERROR pthread_setcancelstate failed, status=%d\n",
printf("asynch_waiter: "
"ERROR pthread_setcancelstate failed, status=%d\n",
status);
}
@ -302,7 +316,8 @@ static void start_thread(FAR void *(*entry)(FAR void *), pthread_t *waiter,
status = pthread_mutex_init(&mutex, NULL);
if (status != 0)
{
printf("start_thread: ERROR pthread_mutex_init failed, status=%d\n", status);
printf("start_thread: "
"ERROR pthread_mutex_init failed, status=%d\n", status);
}
/* Initialize the condition variable */
@ -311,7 +326,8 @@ static void start_thread(FAR void *(*entry)(FAR void *), pthread_t *waiter,
status = pthread_cond_init(&cond, NULL);
if (status != 0)
{
printf("start_thread: ERROR pthread_cond_init failed, status=%d\n", status);
printf("start_thread: ERROR pthread_cond_init failed, status=%d\n",
status);
}
/* Set up attributes */
@ -325,7 +341,8 @@ static void start_thread(FAR void *(*entry)(FAR void *), pthread_t *waiter,
status = pthread_attr_setstacksize(&attr, STACKSIZE);
if (status != 0)
{
printf("start_thread: pthread_attr_setstacksize failed, status=%d\n", status);
printf("start_thread: pthread_attr_setstacksize failed, status=%d\n",
status);
}
/* Start the waiter thread */
@ -335,7 +352,8 @@ static void start_thread(FAR void *(*entry)(FAR void *), pthread_t *waiter,
(pthread_addr_t)((uintptr_t)cancelable));
if (status != 0)
{
printf("start_thread: ERROR pthread_create failed, status=%d\n", status);
printf("start_thread: ERROR pthread_create failed, status=%d\n",
status);
}
/* Make sure that the waiter thread gets a chance to run */
@ -355,18 +373,21 @@ static void restart_thread(FAR void *(*entry)(FAR void *), pthread_t *waiter,
status = pthread_cond_destroy(&cond);
if (status != 0)
{
printf("restart_thread: ERROR pthread_cond_destroy failed, status=%d\n", status);
printf("restart_thread: "
"ERROR pthread_cond_destroy failed, status=%d\n", status);
}
/* Destroy the mutex. Note that this relies on non-portable NuttX assumption,
* that it is possible to destroy a locked mutex owned by a cancelled thread.
/* Destroy the mutex.
* Note that this relies on non-portable NuttX assumption, that it
* is possible to destroy a locked mutex owned by a cancelled thread.
*/
printf("restart_thread: Destroying mutex\n");
status = pthread_mutex_destroy(&mutex);
if (status != 0)
{
printf("restart_thread: ERROR pthread_mutex_destroy failed, status=%d\n", status);
printf("restart_thread: "
"ERROR pthread_mutex_destroy failed, status=%d\n", status);
}
/* Then restart the thread */
@ -389,7 +410,8 @@ void cancel_test(void)
void *result;
int status;
/* Test 1: Normal Cancel *********************************************/
/* Test 1: Normal Cancel **************************************************/
/* Start the waiter thread */
printf("cancel_test: Test 1a: Normal Cancellation\n");
@ -400,13 +422,14 @@ void cancel_test(void)
* make sure.
*/
usleep(75*1000);
usleep(75 * 1000);
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n",
status);
}
/* Then join to the thread to pick up the result (if we don't do
@ -417,22 +440,25 @@ void cancel_test(void)
status = pthread_join(waiter, &result);
if (status != 0)
{
printf("cancel_test: ERROR pthread_join failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_join failed, status=%d\n",
status);
}
else
{
printf("cancel_test: waiter exited with result=%p\n", result);
if (result != PTHREAD_CANCELED)
{
printf("cancel_test: ERROR expected result=%p\n", PTHREAD_CANCELED);
printf("cancel_test: ERROR expected result=%p\n",
PTHREAD_CANCELED);
}
else
{
printf("cancel_test: PASS thread terminated with PTHREAD_CANCELED\n");
printf("cancel_test:"
" PASS thread terminated with PTHREAD_CANCELED\n");
}
}
/* Test 2: Asynchronous Cancel ***************************************/
/* Test 2: Asynchronous Cancel ********************************************/
printf("cancel_test: Test 2: Asynchronous Cancellation\n");
@ -453,13 +479,14 @@ void cancel_test(void)
* bit to make sure.
*/
usleep(100*1000);
usleep(100 * 1000);
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n",
status);
}
/* Then join to the thread to pick up the result (if we don't do
@ -470,25 +497,28 @@ void cancel_test(void)
status = pthread_join(waiter, &result);
if (status != 0)
{
printf("cancel_test: ERROR pthread_join failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_join failed, status=%d\n",
status);
}
else
{
printf("cancel_test: waiter exited with result=%p\n", result);
if (result != PTHREAD_CANCELED)
{
printf("cancel_test: ERROR expected result=%p\n", PTHREAD_CANCELED);
printf("cancel_test: ERROR expected result=%p\n",
PTHREAD_CANCELED);
}
else
{
printf("cancel_test: PASS thread terminated with PTHREAD_CANCELED\n");
printf("cancel_test: "
"PASS thread terminated with PTHREAD_CANCELED\n");
}
}
#else
printf("... Skipped\n");
#endif
/* Test 3: Cancel Detached Thread ************************************/
/* Test 3: Cancel Detached Thread *****************************************/
printf("cancel_test: Test 3: Cancellation of detached thread\n");
printf("cancel_test: Re-starting thread\n");
@ -506,13 +536,14 @@ void cancel_test(void)
* bit to be certain.
*/
usleep(100*1000);
usleep(100 * 1000);
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n",
status);
}
#ifdef CONFIG_CANCELLATION_POINTS
@ -521,7 +552,7 @@ void cancel_test(void)
* before the cancellation.
*/
usleep(100*1000);
usleep(100 * 1000);
#endif
/* Join should now fail */
@ -534,14 +565,17 @@ void cancel_test(void)
}
else if (status != ESRCH)
{
printf("cancel_test: ERROR pthread_join failed but with wrong status=%d\n", status);
printf("cancel_test:"
" ERROR pthread_join failed but with wrong status=%d\n",
status);
}
else
{
printf("cancel_test: PASS pthread_join failed with status=ESRCH\n");
}
/* Test 4: Non-cancelable threads ************************************/
/* Test 4: Non-cancelable threads *****************************************/
/* This test currently depends on signals. It doesn't have to and
* could be re-designed so that it does not depend on signals.
*/
@ -554,7 +588,7 @@ void cancel_test(void)
* This is the dependency on signals:
*/
usleep(200*1000);
usleep(200 * 1000);
/* Then cancel it. It should be in the pthread_cond_wait now. The
* behavior here is non-standard: when the thread is at a cancellation
@ -563,13 +597,14 @@ void cancel_test(void)
* The cancellation should succeed, because the cancellation is pending.
*/
usleep(100*1000);
usleep(100 * 1000);
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n",
status);
}
/* Signal the thread. It should wake up and restore the cancelable state.
@ -579,19 +614,22 @@ void cancel_test(void)
status = pthread_mutex_lock(&mutex);
if (status != 0)
{
printf("cancel_test: ERROR pthread_mutex_lock failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_mutex_lock failed, status=%d\n",
status);
}
status = pthread_cond_signal(&cond);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cond_signal failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_cond_signal failed, status=%d\n",
status);
}
status = pthread_mutex_unlock(&mutex);
if (status != 0)
{
printf("cancel_test: ERROR pthread_mutex_unlock failed, status=%d\n", status);
printf("cancel_test: ERROR pthread_mutex_unlock failed, status=%d\n",
status);
}
/* Then join to the thread to pick up the result (if we don't do
@ -609,11 +647,13 @@ void cancel_test(void)
printf("cancel_test: waiter exited with result=%p\n", result);
if (result != PTHREAD_CANCELED)
{
printf("cancel_test: ERROR expected result=%p\n", PTHREAD_CANCELED);
printf("cancel_test: ERROR expected result=%p\n",
PTHREAD_CANCELED);
}
else
{
printf("cancel_test: PASS thread terminated with PTHREAD_CANCELED\n");
printf("cancel_test: "
"PASS thread terminated with PTHREAD_CANCELED\n");
}
}
@ -629,7 +669,7 @@ void cancel_test(void)
attr.mq_msgsize = CONFIG_MQ_MAXMSGSIZE;
attr.mq_flags = 0;
mqcancel = mq_open("mqcancel", O_WRONLY|O_CREAT, 0666, &attr);
mqcancel = mq_open("mqcancel", O_WRONLY | O_CREAT, 0666, &attr);
if (mqcancel == (mqd_t)-1)
{
printf("sender_thread: ERROR mq_open failed\n");
@ -644,7 +684,7 @@ void cancel_test(void)
* make sure.
*/
usleep(75*1000);
usleep(75 * 1000);
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
@ -675,7 +715,8 @@ void cancel_test(void)
}
else
{
printf("cancel_test: PASS thread terminated with PTHREAD_CANCELED\n");
printf("cancel_test: "
"PASS thread terminated with PTHREAD_CANCELED\n");
}
}
@ -686,7 +727,7 @@ void cancel_test(void)
printf("sender_thread: ERROR mq_close failed\n");
}
#else
printf("Skipped\n");
printf("Skipped\n");
#endif
printf("cancel_test: Test 7: Cancel signal wait\n");
@ -701,7 +742,7 @@ void cancel_test(void)
* make sure.
*/
usleep(75*1000);
usleep(75 * 1000);
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
@ -732,10 +773,11 @@ void cancel_test(void)
}
else
{
printf("cancel_test: PASS thread terminated with PTHREAD_CANCELED\n");
printf("cancel_test: "
"PASS thread terminated with PTHREAD_CANCELED\n");
}
}
#else
printf("Skipped\n");
printf("Skipped\n");
#endif
}

106
testing/ostest/cond.c
View File

@ -18,16 +18,29 @@
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include "ostest.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifndef NULL
# define NULL (void*)0
#endif
static volatile enum { RUNNING, MUTEX_WAIT, COND_WAIT} waiter_state;
static volatile enum
{
RUNNING,
MUTEX_WAIT,
COND_WAIT
} waiter_state;
static pthread_mutex_t mutex;
static pthread_cond_t cond;
@ -40,13 +53,17 @@ static int signaler_already = 0;
static int signaler_state = 0;
static int signaler_nerrors = 0;
/****************************************************************************
* Public Functions
****************************************************************************/
static void *thread_waiter(void *parameter)
{
int status;
printf("waiter_thread: Started\n");
for (;;)
for (; ; )
{
/* Take the mutex */
@ -56,7 +73,8 @@ static void *thread_waiter(void *parameter)
if (status != 0)
{
printf("waiter_thread: ERROR pthread_mutex_lock failed, status=%d\n", status);
printf("waiter_thread: "
"ERROR pthread_mutex_lock failed, status=%d\n", status);
waiter_nerrors++;
}
@ -66,24 +84,27 @@ static void *thread_waiter(void *parameter)
if (!data_available)
{
/* We are higher priority than the signaler thread so the
* only time that the signaler thread will have a chance to run is when
* we are waiting for the condition variable. In this case, pthread_cond_wait
* will automatically release the mutex for the signaler (then re-acquire
* the mutex before returning.
*/
/* We are higher priority than the signaler thread so the
* only time that the signaler thread will have a chance to run
* is when we are waiting for the condition variable.
* In this case, pthread_cond_wait will automatically release
* the mutex for the signaler (then re-acquire the mutex before
* returning.
*/
waiter_state = COND_WAIT;
status = pthread_cond_wait(&cond, &mutex);
waiter_state = RUNNING;
waiter_state = COND_WAIT;
status = pthread_cond_wait(&cond, &mutex);
waiter_state = RUNNING;
if (status != 0)
{
printf("waiter_thread: ERROR pthread_cond_wait failed, status=%d\n", status);
waiter_nerrors++;
}
if (status != 0)
{
printf("waiter_thread: "
"ERROR pthread_cond_wait failed, status=%d\n",
status);
waiter_nerrors++;
}
waiter_waits++;
waiter_waits++;
}
/* Now data should be available */
@ -103,7 +124,8 @@ static void *thread_waiter(void *parameter)
status = pthread_mutex_unlock(&mutex);
if (status != 0)
{
printf("waiter_thread: ERROR waiter: pthread_mutex_unlock failed, status=%d\n", status);
printf("waiter_thread: ERROR waiter: "
"pthread_mutex_unlock failed, status=%d\n", status);
waiter_nerrors++;
}
@ -129,7 +151,8 @@ static void *thread_signaler(void *parameter)
status = pthread_mutex_lock(&mutex);
if (status != 0)
{
printf("thread_signaler: ERROR pthread_mutex_lock failed, status=%d\n", status);
printf("thread_signaler: "
"ERROR pthread_mutex_lock failed, status=%d\n", status);
signaler_nerrors++;
}
@ -137,13 +160,16 @@ static void *thread_signaler(void *parameter)
if (waiter_state != COND_WAIT)
{
printf("thread_signaler: ERROR waiter state = %d != COND_WAITING\n", waiter_state);
printf("thread_signaler: "
"ERROR waiter state = %d != COND_WAITING\n", waiter_state);
signaler_state++;
}
if (data_available)
{
printf("thread_signaler: ERROR data already available, waiter_state=%d\n", waiter_state);
printf("thread_signaler: "
"ERROR data already available, waiter_state=%d\n",
waiter_state);
signaler_already++;
}
@ -153,16 +179,18 @@ static void *thread_signaler(void *parameter)
status = pthread_cond_signal(&cond);
if (status != 0)
{
printf("thread_signaler: ERROR pthread_cond_signal failed, status=%d\n", status);
printf("thread_signaler: "
"ERROR pthread_cond_signal failed, status=%d\n", status);
signaler_nerrors++;
}
/* Release the mutex */
/* Release the mutex */
status = pthread_mutex_unlock(&mutex);
if (status != 0)
{
printf("thread_signaler: ERROR pthread_mutex_unlock failed, status=%d\n", status);
printf("thread_signaler: "
"ERROR pthread_mutex_unlock failed, status=%d\n", status);
signaler_nerrors++;
}
@ -207,7 +235,8 @@ void cond_test(void)
status = pthread_mutex_init(&mutex, NULL);
if (status != 0)
{
printf("cond_test: ERROR pthread_mutex_init failed, status=%d\n", status);
printf("cond_test: "
"ERROR pthread_mutex_init failed, status=%d\n", status);
}
/* Initialize the condition variable */
@ -216,7 +245,8 @@ void cond_test(void)
status = pthread_cond_init(&cond, NULL);
if (status != 0)
{
printf("cond_test: ERROR pthread_condinit failed, status=%d\n", status);
printf("cond_test: "
"ERROR pthread_condinit failed, status=%d\n", status);
}
/* Start the waiter thread at higher priority */
@ -233,14 +263,16 @@ void cond_test(void)
prio_mid = (prio_min + prio_max) / 2;
sparam.sched_priority = prio_mid;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("cond_test: pthread_attr_setschedparam failed, status=%d\n", status);
printf("cond_test: "
"pthread_attr_setschedparam failed, status=%d\n", status);
}
else
{
printf("cond_test: Set thread 1 priority to %d\n", sparam.sched_priority);
printf("cond_test: Set thread 1 priority to %d\n",
sparam.sched_priority);
}
status = pthread_create(&waiter, &attr, thread_waiter, NULL);
@ -257,14 +289,16 @@ void cond_test(void)
}
sparam.sched_priority = (prio_min + prio_mid) / 2;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("cond_test: pthread_attr_setschedparam failed, status=%d\n", status);
printf("cond_test: pthread_attr_setschedparam failed, status=%d\n",
status);
}
else
{
printf("cond_test: Set thread 2 priority to %d\n", sparam.sched_priority);
printf("cond_test: Set thread 2 priority to %d\n",
sparam.sched_priority);
}
status = pthread_create(&signaler, &attr, thread_signaler, NULL);
@ -290,8 +324,10 @@ void cond_test(void)
printf("cond_test:\n");
printf("cond_test: %d times, waiter did not have to wait for data\n",
waiter_nloops - waiter_waits);
printf("cond_test: %d times, data was already available when the signaler run\n",
printf("cond_test: %d times, "
"data was already available when the signaler run\n",
signaler_already);
printf("cond_test: %d times, the waiter was in an unexpected state when the signaler ran\n",
printf("cond_test: %d times, "
"the waiter was in an unexpected state when the signaler ran\n",
signaler_state);
}

10
testing/ostest/nsem.c
View File

@ -73,7 +73,7 @@ static FAR void *nsem_peer(void *parameter)
/* Open semaphore 2. We will create that one */
printf("nsem_peer: Create semaphore 2 with value == 0\n");
sem2 = sem_open(SEM2_NAME, O_CREAT|O_EXCL, 0644, 0);
sem2 = sem_open(SEM2_NAME, O_CREAT | O_EXCL, 0644, 0);
if (sem1 == SEM_FAILED)
{
int errcode = errno;
@ -118,7 +118,7 @@ void nsem_test(void)
/* Open semaphore 2. We will create that one */
printf("nsem_test: Create semaphore 1 with value == 0\n");
sem1 = sem_open(SEM1_NAME, O_CREAT|O_EXCL, 0644, 0);
sem1 = sem_open(SEM1_NAME, O_CREAT | O_EXCL, 0644, 0);
if (sem1 == SEM_FAILED)
{
int errcode = errno;
@ -140,10 +140,12 @@ void nsem_test(void)
prio_mid = (prio_min + prio_max) / 2;
sparam.sched_priority = (prio_mid + prio_max) / 2;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("nsem_test: ERROR: pthread_attr_setschedparam failed, status=%d\n", status);
printf("nsem_test: "
"ERROR: pthread_attr_setschedparam failed, status=%d\n",
status);
}
else
{

50
testing/ostest/pthread_rwlock.c
View File

@ -40,6 +40,7 @@ struct race_cond_s
/****************************************************************************
* Private Data
****************************************************************************/
static int g_race_cond_thread_pos;
/****************************************************************************
@ -85,7 +86,8 @@ static FAR void *race_cond_thread1(FAR void *data)
status = pthread_rwlock_rdlock(rc->rw_lock);
if (status != 0)
{
printf("pthread_rwlock: Failed to open rwlock for reading. Status: %d\n", status);
printf("pthread_rwlock: "
"Failed to open rwlock for reading. Status: %d\n", status);
}
sem_wait(rc->sem1);
@ -107,7 +109,8 @@ static FAR void *race_cond_thread1(FAR void *data)
status = pthread_rwlock_rdlock(rc->rw_lock);
if (status != 0)
{
printf("pthread_rwlock: Failed to open rwlock for reading. Status: %d\n", status);
printf("pthread_rwlock: "
"Failed to open rwlock for reading. Status: %d\n", status);
}
sem_post(rc->sem2);
@ -124,7 +127,8 @@ static FAR void *race_cond_thread1(FAR void *data)
status = pthread_rwlock_unlock(rc->rw_lock);
if (status != 0)
{
printf("pthread_rwlock: Failed to unlock lock held for reading. Status: %d\n", status);
printf("pthread_rwlock: "
"Failed to unlock lock held for reading. Status: %d\n", status);
}
return NULL;
@ -141,25 +145,31 @@ static FAR void *race_cond_thread2(FAR void *data)
if (status != 0)
{
printf("pthread_rwlock: Failed to wait on semaphore. Status: %d\n", status);
printf("pthread_rwlock: "
"Failed to wait on semaphore. Status: %d\n", status);
}
if (g_race_cond_thread_pos++ != 1)
{
printf("pthread_rwlock: Thread order unexpected. Expected 1, got %d", g_race_cond_thread_pos);
printf("pthread_rwlock: "
"Thread order unexpected. Expected 1, got %d",
g_race_cond_thread_pos);
}
status = pthread_rwlock_tryrdlock(rc->rw_lock);
if (status != EBUSY)
{
printf("pthread_rwlock: Opened rw_lock for rd when locked for writing: %d\n", status);
printf("pthread_rwlock: "
"Opened rw_lock for rd when locked for writing: %d\n", status);
}
status = pthread_rwlock_trywrlock(rc->rw_lock);
if (status != EBUSY)
{
printf("pthread_rwlock: Opened rw_lock for wr when locked for writing: %d\n", status);
printf("pthread_rwlock: "
"Opened rw_lock for wr when locked for writing: %d\n", status);
}
sem_post(rc->sem1);
status = pthread_rwlock_rdlock(rc->rw_lock);
@ -167,7 +177,8 @@ static FAR void *race_cond_thread2(FAR void *data)
if (status != 0)
{
printf("pthread_rwlock: Failed to open rwlock for reading. Status: %d\n", status);
printf("pthread_rwlock: "
"Failed to open rwlock for reading. Status: %d\n", status);
}
if (g_race_cond_thread_pos++ != 3)
@ -200,7 +211,8 @@ static FAR void *race_cond_thread2(FAR void *data)
if (status != 0)
{
printf("pthread_rwlock: Failed to open rwlock for reading. Status: %d\n", status);
printf("pthread_rwlock: "
"Failed to open rwlock for reading. Status: %d\n", status);
}
if (g_race_cond_thread_pos++ != 7)
@ -212,7 +224,8 @@ static FAR void *race_cond_thread2(FAR void *data)
status = pthread_rwlock_unlock(rc->rw_lock);
if (status != 0)
{
printf("pthread_rwlock: Failed to unlock lock held for writing. Status: %d\n", status);
printf("pthread_rwlock: "
"Failed to unlock lock held for writing. Status: %d\n", status);
}
return NULL;
@ -231,7 +244,8 @@ static void test_two_threads(void)
status = pthread_rwlock_init(&rw_lock, NULL);
if (status != 0)
{
printf("pthread_rwlock: ERROR pthread_rwlock_init failed, status=%d\n", status);
printf("pthread_rwlock: "
"ERROR pthread_rwlock_init failed, status=%d\n", status);
}
status = sem_init(&sem1, 0, 0);
@ -265,7 +279,8 @@ static void * timeout_thread1(FAR void * data)
status = pthread_rwlock_wrlock(rc->rw_lock);
if (status != 0)
{
printf("pthread_rwlock: Failed to acquire rw_lock. Status: %d\n", status);
printf("pthread_rwlock: Failed to acquire rw_lock. Status: %d\n",
status);
}
sem_wait(rc->sem1);
@ -273,7 +288,8 @@ static void * timeout_thread1(FAR void * data)
status = pthread_rwlock_unlock(rc->rw_lock);
if (status != 0)
{
printf("pthread_rwlock: Failed to unlock rw_lock. Status: %d\n", status);
printf("pthread_rwlock: Failed to unlock rw_lock. Status: %d\n",
status);
}
return NULL;
@ -408,15 +424,15 @@ void pthread_rwlock_test(void)
status = pthread_rwlock_trywrlock(&rw_lock);
if (status != EBUSY)
{
printf("pthread_rwlock: "
"ERROR able to acquire write lock when write lock already acquired\n");
printf("pthread_rwlock: ERROR "
"able to acquire write lock when write lock already acquired\n");
}
status = pthread_rwlock_tryrdlock(&rw_lock);
if (status != EBUSY)
{
printf("pthread_rwlock: "
"ERROR able to acquire read lock when write lock already acquired\n");
printf("pthread_rwlock: ERROR "
"able to acquire read lock when write lock already acquired\n");
}
status = pthread_rwlock_unlock(&rw_lock);

19
testing/ostest/restart.c
View File

@ -45,7 +45,7 @@
* Private Data
****************************************************************************/
static char * const g_argv[NARGS+1] =
static char * const g_argv[NARGS + 1] =
{
"This is argument 1",
"Argument 2 here",
@ -78,16 +78,17 @@ static int restart_main(int argc, char *argv[])
if (argc != NARGS + 1)
{
printf("restart_main: ERROR: Expected argc=%d got argc=%d\n",
NARGS+1, argc);
NARGS + 1, argc);
}
for (i = 0; i <= NARGS; i++)
{
printf("restart_main: argv[%d]=\"%s\"\n", i, argv[i]);
if (i > 0 && strcmp(argv[i], g_argv[i-1]) != 0)
if (i > 0 && strcmp(argv[i], g_argv[i - 1]) != 0)
{
printf("restart_main: ERROR: Expected argv[%d]=\"%s\" got \"%s\"\n",
i, argv[i], g_argv[i-1]);
printf("restart_main: ERROR: "
"Expected argv[%d]=\"%s\" got \"%s\"\n",
i, argv[i], g_argv[i - 1]);
}
}
@ -102,8 +103,10 @@ static int restart_main(int argc, char *argv[])
}
else
{
printf("restart_main: ERROR Variable=%s has the wrong value\n", g_varname);
printf("restart_main: found=%s expected=%s\n", actual, g_varvalue);
printf("restart_main: ERROR Variable=%s has the wrong value\n",
g_varname);
printf("restart_main: found=%s expected=%s\n",
actual, g_varvalue);
}
}
else
@ -122,7 +125,7 @@ static int restart_main(int argc, char *argv[])
/* Now just wait to be restarted */
for (;;)
for (; ; )
{
sleep(2);
printf("restart_main: I am still here\n");

56
testing/ostest/rmutex.c
View File

@ -18,16 +18,28 @@
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <stdio.h>
#include <pthread.h>
#include "ostest.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define NTHREADS 3
#define NLOOPS 3
#define NRECURSIONS 3
static pthread_mutex_t mut;
/****************************************************************************
* Public Functions
****************************************************************************/
static void thread_inner(int id, int level)
{
int status;
@ -39,9 +51,11 @@ static void thread_inner(int id, int level)
status = pthread_mutex_lock(&mut);
if (status != 0)
{
printf("thread_inner[%d, %d]: ERROR pthread_mutex_lock failed: %d\n",
printf("thread_inner[%d, %d]: "
"ERROR pthread_mutex_lock failed: %d\n",
id, level, status);
}
printf("thread_inner[%d, %d]: Locked\n", id, level);
/* Try-lock already locked recursive mutex. */
@ -49,7 +63,8 @@ static void thread_inner(int id, int level)
status = pthread_mutex_trylock(&mut);
if (status != 0)
{
printf("thread_inner[%d, %d]: ERROR pthread_mutex_trylock failed: %d\n",
printf("thread_inner[%d, %d]: "
"ERROR pthread_mutex_trylock failed: %d\n",
id, level, status);
}
else
@ -59,15 +74,16 @@ static void thread_inner(int id, int level)
status = pthread_mutex_unlock(&mut);
if (status != 0)
{
printf("thread_inner[%d, %d]: ERROR pthread_mutex_unlock after try-lock failed: %d\n",
id, level, status);
printf("thread_inner[%d, %d]: ERROR "
"pthread_mutex_unlock after try-lock failed: %d\n",
id, level, status);
}
}
/* Give the other threads a chance */
pthread_yield();
thread_inner(id, level+1);
thread_inner(id, level + 1);
pthread_yield();
/* Unlock the mutex */
@ -76,9 +92,11 @@ static void thread_inner(int id, int level)
status = pthread_mutex_unlock(&mut);
if (status != 0)
{
printf("thread_inner[%d, %d]: ERROR pthread_mutex_unlock failed: %d\n",
printf("thread_inner[%d, %d]: "
"ERROR pthread_mutex_unlock failed: %d\n",
id, level, status);
}
printf("thread_inner[%d, %d]: Unlocked\n", id, level);
pthread_yield();
}
@ -118,17 +136,21 @@ void recursive_mutex_test(void)
status = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
if (status != 0)
{
printf("recursive_mutex_test: ERROR pthread_mutexattr_settype failed, status=%d\n", status);
printf("recursive_mutex_test: "
"ERROR pthread_mutexattr_settype failed, status=%d\n", status);
}
status = pthread_mutexattr_gettype(&mattr, &type);
if (status != 0)
{
printf("recursive_mutex_test: ERROR pthread_mutexattr_gettype failed, status=%d\n", status);
printf("recursive_mutex_test: "
"ERROR pthread_mutexattr_gettype failed, status=%d\n", status);
}
if (type != PTHREAD_MUTEX_RECURSIVE)
{
printf("recursive_mutex_test: ERROR pthread_mutexattr_gettype return type=%d\n", type);
printf("recursive_mutex_test: "
"ERROR pthread_mutexattr_gettype return type=%d\n", type);
}
/* Initialize the mutex */
@ -137,23 +159,27 @@ void recursive_mutex_test(void)
status = pthread_mutex_init(&mut, &mattr);
if (status != 0)
{
printf("recursive_mutex_test: ERROR pthread_mutex_init failed, status=%d\n", status);
printf("recursive_mutex_test: "
"ERROR pthread_mutex_init failed, status=%d\n", status);
}
/* Start the threads -- all at the same, default priority */
for (i = 0; i < NTHREADS; i++)
{
printf("recursive_mutex_test: Starting thread %d\n", i+1);
printf("recursive_mutex_test: Starting thread %d\n", i + 1);
#ifdef SDCC
pthread_attr_init(&attr);
status = pthread_create(&thread[i], &attr, thread_outer, (pthread_addr_t)((uintptr_t)i+1));
status = pthread_create(&thread[i], &attr, thread_outer,
(pthread_addr_t)((uintptr_t)i + 1));
#else
status = pthread_create(&thread[i], NULL, thread_outer, (pthread_addr_t)((uintptr_t)i+1));
status = pthread_create(&thread[i], NULL, thread_outer,
(pthread_addr_t)((uintptr_t)i + 1));
#endif
if (status != 0)
{
printf("recursive_mutex_test: ERROR thread#%d creation: %d\n", i+1, status);
printf("recursive_mutex_test: ERROR thread#%d creation: %d\n",
i + 1, status);
}
}
@ -161,7 +187,7 @@ void recursive_mutex_test(void)
for (i = 0; i < NTHREADS; i++)
{
printf("recursive_mutex_test: Waiting for thread %d\n", i+1);
printf("recursive_mutex_test: Waiting for thread %d\n", i + 1);
#ifdef SDCC
pthread_join(thread[i], &result[i]);
#else

43
testing/ostest/robust.c
View File

@ -51,12 +51,14 @@ static FAR void *robust_waiter(FAR void *parameter)
status = pthread_mutex_lock(&g_robust_mutex);
if (status != 0)
{
printf("thread_waiter: ERROR: pthread_mutex_lock failed, status=%d\n", status);
printf("thread_waiter: ERROR: pthread_mutex_lock failed, status=%d\n",
status);
}
if (status != 0)
{
printf("robust_waiter: ERROR: pthread_mutex_lock failed, status=%d\n", status);
printf("robust_waiter: ERROR: pthread_mutex_lock failed, status=%d\n",
status);
}
else
{
@ -87,7 +89,8 @@ void robust_test(void)
status = pthread_mutexattr_init(&mattr);
if (status != 0)
{
printf("robust_test: ERROR: pthread_mutexattr_init failed, status=%d\n",
printf("robust_test: ERROR: "
"pthread_mutexattr_init failed, status=%d\n",
status);
nerrors++;
}
@ -95,7 +98,8 @@ void robust_test(void)
status = pthread_mutexattr_setrobust(&mattr, PTHREAD_MUTEX_ROBUST);
if (status != 0)
{
printf("robust_test: ERROR: pthread_mutexattr_setrobust failed, status=%d\n",
printf("robust_test: ERROR: "
"pthread_mutexattr_setrobust failed, status=%d\n",
status);
nerrors++;
}
@ -123,7 +127,8 @@ void robust_test(void)
status = pthread_attr_setstacksize(&pattr, STACKSIZE);
if (status != 0)
{
printf("robust_test: ERROR: pthread_attr_setstacksize failed, status=%d\n",
printf("robust_test: ERROR: "
"pthread_attr_setstacksize failed, status=%d\n",
status);
nerrors++;
}
@ -135,7 +140,8 @@ void robust_test(void)
status = pthread_create(&waiter, &pattr, robust_waiter, NULL);
if (status != 0)
{
printf("robust_test: ERROR: pthread_create failed, status=%d\n", status);
printf("robust_test: ERROR: "
"pthread_create failed, status=%d\n", status);
printf(" ERROR: Terminating test\n");
nerrors++;
return;
@ -157,12 +163,15 @@ void robust_test(void)
}
else if (status != EOWNERDEAD)
{
printf("robust_test: ERROR: pthread_mutex_lock failed with %d\n", status);
printf("robust_test: ERROR: pthread_mutex_lock failed with %d\n",
status);
printf(" ERROR: expected %d (EOWNERDEAD)\n", EOWNERDEAD);
nerrors++;
}
/* Try again, this should return immediately, still failing with EOWNERDEAD */
/* Try again,
* this should return immediately, still failing with EOWNERDEAD
*/
printf("robust_test: Take the lock again\n");
status = pthread_mutex_lock(&g_robust_mutex);
@ -173,7 +182,8 @@ void robust_test(void)
}
else if (status != EOWNERDEAD)
{
printf("robust_test: ERROR: pthread_mutex_lock failed with %d\n", status);
printf("robust_test: ERROR: pthread_mutex_lock failed with %d\n",
status);
printf(" ERROR: expected %d (EOWNERDEAD)\n", EOWNERDEAD);
nerrors++;
}
@ -184,7 +194,8 @@ void robust_test(void)
status = pthread_mutex_consistent(&g_robust_mutex);
if (status != 0)
{
printf("robust_test: ERROR: pthread_mutex_consistent failed: %d\n", status);
printf("robust_test: ERROR: pthread_mutex_consistent failed: %d\n",
status);
nerrors++;
}
@ -192,7 +203,8 @@ void robust_test(void)
status = pthread_mutex_lock(&g_robust_mutex);
if (status != 0)
{
printf("robust_test: ERROR: pthread_mutex_lock failed with: %d\n", status);
printf("robust_test: ERROR: pthread_mutex_lock failed with: %d\n",
status);
nerrors++;
}
@ -212,7 +224,8 @@ void robust_test(void)
printf("robust_test: waiter exited with result=%p\n", result);
if (result != NULL)
{
printf("robust_test: ERROR: expected result=%p\n", PTHREAD_CANCELED);
printf("robust_test: ERROR: expected result=%p\n",
PTHREAD_CANCELED);
nerrors++;
}
}
@ -222,14 +235,16 @@ void robust_test(void)
status = pthread_mutex_unlock(&g_robust_mutex);
if (status != 0)
{
printf("robust_test: ERROR: pthread_mutex_unlock failed, status=%d\n", status);
printf("robust_test: ERROR: pthread_mutex_unlock failed, status=%d\n",
status);
nerrors++;
}
status = pthread_mutex_destroy(&g_robust_mutex);
if (status != 0)
{
printf("robust_test: ERROR: pthread_mutex_unlock failed, status=%d\n", status);
printf("robust_test: ERROR: pthread_mutex_unlock failed, status=%d\n",
status);
nerrors++;
}

56
testing/ostest/roundrobin.c
View File

@ -39,7 +39,8 @@
/* This numbers should be tuned for different processor speeds via .config file.
* With default values the test takes about 30s on Cortex-M3 @ 24MHz. With 32767
* range and 10 runs it takes ~320s. */
* range and 10 runs it takes ~320s.
*/
#ifndef CONFIG_TESTING_OSTEST_RR_RANGE
# define CONFIG_TESTING_OSTEST_RR_RANGE 10000
@ -82,26 +83,26 @@ static void get_primes(int *count, int *last)
*last = 0; /* To make the compiler happy */
for (number = 1; number < CONFIG_TESTING_OSTEST_RR_RANGE; number++)
{
int div;
bool is_prime = true;
for (div = 2; div <= number / 2; div++)
if (number % div == 0)
{
is_prime = false;
break;
}
if (is_prime)
{
local_count++;
*last = number;
int div;
bool is_prime = true;
for (div = 2; div <= number / 2; div++)
if (number % div == 0)
{
is_prime = false;
break;
}
if (is_prime)
{
local_count++;
*last = number;
#if 0 /* We don't really care what the numbers are */
printf(" Prime %d: %d\n", local_count, number);
printf(" Prime %d: %d\n", local_count, number);
#endif
}
}
}
*count = local_count;
}
@ -119,7 +120,8 @@ static FAR void *get_primes_thread(FAR void *parameter)
while (sem_wait(&g_rrsem) < 0);
printf("get_primes_thread id=%d started, looking for primes < %d, doing %d run(s)\n",
printf("get_primes_thread id=%d started, "
"looking for primes < %d, doing %d run(s)\n",
id, CONFIG_TESTING_OSTEST_RR_RANGE, CONFIG_TESTING_OSTEST_RR_RUNS);
for (i = 0; i < CONFIG_TESTING_OSTEST_RR_RUNS; i++)
@ -163,7 +165,8 @@ void rr_test(void)
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("rr_test: ERROR: pthread_attr_setschedparam failed, status=%d\n", status);
printf("rr_test: ERROR: pthread_attr_setschedparam failed, status=%d\n",
status);
}
else
{
@ -173,7 +176,8 @@ void rr_test(void)
status = pthread_attr_setschedpolicy(&attr, SCHED_RR);
if (status != OK)
{
printf("rr_test: ERROR: pthread_attr_setschedpolicy failed, status=%d\n", status);
printf("rr_test: ERROR: pthread_attr_setschedpolicy failed, status=%d\n",
status);
}
else
{
@ -189,7 +193,8 @@ void rr_test(void)
printf("rr_test: Starting first get_primes_thread\n");
status = pthread_create(&get_primes1_thread, &attr, get_primes_thread, (FAR void *)1);
status = pthread_create(&get_primes1_thread,
&attr, get_primes_thread, (FAR void *)1);
if (status != 0)
{
printf(" ERROR: Thread 1 creation failed: %d\n", status);
@ -198,15 +203,18 @@ void rr_test(void)
printf(" First get_primes_thread: %d\n", (int)get_primes1_thread);
printf("rr_test: Starting second get_primes_thread\n");
status = pthread_create(&get_primes2_thread, &attr, get_primes_thread, (FAR void *)2);
status = pthread_create(&get_primes2_thread,
&attr, get_primes_thread, (FAR void *)2);
if (status != 0)
{
printf(" ERROR: Thread 2 creation failed: %d\n", status);
}
printf(" Second get_primes_thread: %d\n", (int)get_primes2_thread);
printf("rr_test: Waiting for threads to complete -- this should take awhile\n");
printf(" If RR scheduling is working, they should start and complete at\n");
printf("rr_test: "
"Waiting for threads to complete -- this should take awhile\n");
printf(" "
"If RR scheduling is working, they should start and complete at\n");
printf(" about the same time\n");
sem_post(&g_rrsem);

68
testing/ostest/sem.c
View File

@ -59,11 +59,13 @@ static void *waiter_func(void *parameter)
status = sem_getvalue(&sem, &value);
if (status < 0)
{
printf("waiter_func: ERROR thread %d could not get semaphore value\n", id);
printf("waiter_func: "
"ERROR thread %d could not get semaphore value\n", id);
}
else
{
printf("waiter_func: Thread %d initial semaphore value = %d\n", id, value);
printf("waiter_func: "
"Thread %d initial semaphore value = %d\n", id, value);
}
printf("waiter_func: Thread %d waiting on semaphore\n", id);
@ -72,16 +74,19 @@ static void *waiter_func(void *parameter)
{
printf("waiter_func: ERROR thread %d sem_wait failed\n", id);
}
printf("waiter_func: Thread %d awakened\n", id);
status = sem_getvalue(&sem, &value);
if (status < 0)
{
printf("waiter_func: ERROR thread %d could not get semaphore value\n", id);
printf("waiter_func: "
"ERROR thread %d could not get semaphore value\n", id);
}
else
{
printf("waiter_func: Thread %d new semaphore value = %d\n", id, value);
printf("waiter_func: "
"Thread %d new semaphore value = %d\n", id, value);
}
printf("waiter_func: Thread %d done\n", id);
@ -103,11 +108,13 @@ static void *poster_func(void *parameter)
status = sem_getvalue(&sem, &value);
if (status < 0)
{
printf("poster_func: ERROR thread %d could not get semaphore value\n", id);
printf("poster_func: "
"ERROR thread %d could not get semaphore value\n", id);
}
else
{
printf("poster_func: Thread %d semaphore value = %d\n", id, value);
printf("poster_func: "
"Thread %d semaphore value = %d\n", id, value);
}
if (value < 0)
@ -124,11 +131,13 @@ static void *poster_func(void *parameter)
status = sem_getvalue(&sem, &value);
if (status < 0)
{
printf("poster_func: ERROR thread %d could not get semaphore value\n", id);
printf("poster_func: "
"ERROR thread %d could not get semaphore value\n", id);
}
else
{
printf("poster_func: Thread %d new semaphore value = %d\n", id, value);
printf("poster_func: "
"Thread %d new semaphore value = %d\n", id, value);
}
}
}
@ -136,7 +145,6 @@ static void *poster_func(void *parameter)
printf("poster_func: Thread %d done\n", id);
return NULL;
}
/****************************************************************************
@ -175,41 +183,49 @@ void sem_test(void)
prio_mid = (prio_min + prio_max) / 2;
sparam.sched_priority = (prio_mid + prio_max) / 2;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("sem_test: ERROR: pthread_attr_setschedparam failed, status=%d\n", status);
printf("sem_test: ERROR: "
"pthread_attr_setschedparam failed, status=%d\n", status);
}
else
{
printf("sem_test: Set thread 1 priority to %d\n", sparam.sched_priority);
printf("sem_test: "
"Set thread 1 priority to %d\n", sparam.sched_priority);
}
status = pthread_create(&waiter_thread1, &attr, waiter_func, (pthread_addr_t)1);
status = pthread_create(&waiter_thread1, &attr,
waiter_func, (pthread_addr_t)1);
if (status != 0)
{
printf("sem_test: ERROR: Thread 1 creation failed: %d\n", status);
printf("sem_test: ERROR: "
"Thread 1 creation failed: %d\n", status);
}
printf("sem_test: Starting waiter thread 2\n");
status = pthread_attr_init(&attr);
if (status != 0)
{
printf("sem_test: ERROR: pthread_attr_init failed, status=%d\n", status);
printf("sem_test: ERROR: "
"pthread_attr_init failed, status=%d\n", status);
}
sparam.sched_priority = prio_mid;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("sem_test: ERROR: pthread_attr_setschedparam failed, status=%d\n", status);
printf("sem_test: ERROR: "
"pthread_attr_setschedparam failed, status=%d\n", status);
}
else
{
printf("sem_test: Set thread 2 priority to %d\n", sparam.sched_priority);
printf("sem_test: "
"Set thread 2 priority to %d\n", sparam.sched_priority);
}
status = pthread_create(&waiter_thread2, &attr, waiter_func, (pthread_addr_t)2);
status = pthread_create(&waiter_thread2, &attr,
waiter_func, (pthread_addr_t)2);
if (status != 0)
{
printf("sem_test: ERROR: Thread 2 creation failed: %d\n", status);
@ -219,21 +235,25 @@ void sem_test(void)
status = pthread_attr_init(&attr);
if (status != 0)
{
printf("sem_test: ERROR: pthread_attr_init failed, status=%d\n", status);
printf("sem_test: ERROR: "
"pthread_attr_init failed, status=%d\n", status);
}
sparam.sched_priority = (prio_min + prio_mid) / 2;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("sem_test: pthread_attr_setschedparam failed, status=%d\n", status);
printf("sem_test: "
"pthread_attr_setschedparam failed, status=%d\n", status);
}
else
{
printf("sem_test: Set thread 3 priority to %d\n", sparam.sched_priority);
printf("sem_test: Set thread 3 priority to %d\n",
sparam.sched_priority);
}
status = pthread_create(&poster_thread, &attr, poster_func, (pthread_addr_t)3);
status = pthread_create(&poster_thread, &attr,
poster_func, (pthread_addr_t)3);
if (status != 0)
{
printf("sem_test: ERROR: Thread 3 creation failed: %d\n", status);

43
testing/ostest/semtimed.c
View File

@ -77,7 +77,8 @@ static void ostest_gettime(struct timespec *tp)
{
printf("ostest_gettime: ERROR: clock_gettime failed\n");
}
else if (tp->tv_sec < 0 || tp->tv_nsec < 0 || tp->tv_nsec >= 1000*1000*1000)
else if (tp->tv_sec < 0 || tp->tv_nsec < 0 ||
tp->tv_nsec >= 1000 * 1000 * 1000)
{
printf("ostest_gettime: ERROR: clock_gettime returned bogus time\n");
}
@ -111,7 +112,9 @@ void semtimed_test(void)
printf("semtimed_test: ERROR: sem_init failed\n");
}
/* First, make sure that the timeout expires if the semaphore is never posted */
/* First,
* make sure that the timeout expires if the semaphore is never posted
*/
ostest_gettime(&before);
@ -136,7 +139,8 @@ void semtimed_test(void)
}
else
{
printf("semtimed_test: ERROR: sem_timedwait failed with: %d\n", errcode);
printf("semtimed_test: ERROR: sem_timedwait failed with: %d\n",
errcode);
}
}
@ -145,14 +149,18 @@ void semtimed_test(void)
printf("AFTER: (%lu sec, %lu nsec)\n",
(unsigned long)after.tv_sec, (unsigned long)after.tv_nsec);
/* Now make sure that the time wait returns successfully if the semaphore is posted */
/* Now make sure that the time wait returns successfully if the semaphore
* is posted
*/
/* Start a poster thread. It will wait 1 seconds and post the semaphore */
printf("semtimed_test: Starting poster thread\n");
status = pthread_attr_init(&attr);
if (status != OK)
{
printf("semtimed_test: ERROR: pthread_attr_init failed, status=%d\n", status);
printf("semtimed_test: ERROR: pthread_attr_init failed, status=%d\n",
status);
}
prio_min = sched_get_priority_min(SCHED_FIFO);
@ -160,38 +168,44 @@ void semtimed_test(void)
prio_mid = (prio_min + prio_max) / 2;
sparam.sched_priority = (prio_mid + prio_max) / 2;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("semtimed_test: ERROR: pthread_attr_setschedparam failed, status=%d\n", status);
printf("semtimed_test: ERROR: "
"pthread_attr_setschedparam failed, status=%d\n", status);
}
else
{
printf("semtimed_test: Set thread 1 priority to %d\n", sparam.sched_priority);
printf("semtimed_test: Set thread 1 priority to %d\n",
sparam.sched_priority);
}
printf("semtimed_test: Starting poster thread 3\n");
status = pthread_attr_init(&attr);
if (status != 0)
{
printf("semtimed_test: ERROR: pthread_attr_init failed, status=%d\n", status);
printf("semtimed_test: ERROR: pthread_attr_init failed, status=%d\n",
status);
}
sparam.sched_priority = (prio_min + prio_mid) / 2;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("semtimed_test: pthread_attr_setschedparam failed, status=%d\n", status);
printf("semtimed_test: pthread_attr_setschedparam failed, status=%d\n",
status);
}
else
{
printf("semtimed_test: Set thread 3 priority to %d\n", sparam.sched_priority);
printf("semtimed_test: Set thread 3 priority to %d\n",
sparam.sched_priority);
}
status = pthread_create(&poster_thread, &attr, poster_func, NULL);
if (status != 0)
{
printf("semtimed_test: ERROR: Poster thread creation failed: %d\n", status);
printf("semtimed_test: ERROR: Poster thread creation failed: %d\n",
status);
sem_destroy(&sem);
return;
}
@ -211,7 +225,8 @@ void semtimed_test(void)
if (status < 0)
{
printf("semtimed_test: ERROR: sem_timedwait failed with: %d\n", errcode);
printf("semtimed_test: ERROR: sem_timedwait failed with: %d\n",
errcode);
}
else
{

17
testing/ostest/sigprocmask.c
View File

@ -18,6 +18,10 @@
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <sys/types.h>
#include <stdbool.h>
#include <stdio.h>
@ -37,7 +41,14 @@
* Private Data
****************************************************************************/
static int g_some_signals[NSIGNALS] = {1, 3, 5, 7, 9};
static int g_some_signals[NSIGNALS] =
{
1,
3,
5,
7,
9
};
/****************************************************************************
* Public Functions
@ -187,7 +198,7 @@ void sigprocmask_test(void)
goto errout;
}
printf("sigprocmask_test: SUCCESS\n" );
printf("sigprocmask_test: SUCCESS\n");
FFLUSH();
return;
@ -201,6 +212,6 @@ errout_with_mask:
}
errout:
printf("sigprocmask_test: Aborting\n" );
printf("sigprocmask_test: Aborting\n");
FFLUSH();
}

30
testing/ostest/suspend.c
View File

@ -18,6 +18,10 @@
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <sys/types.h>
#include <stdbool.h>
#include <stdio.h>
@ -29,27 +33,23 @@
#include "ostest.h"
/****************************************************************************
* Private Functions
* Public Functions
****************************************************************************/
static int victim_main(int argc, char *argv[])
{
printf("victim_main: Victim started\n" );
printf("victim_main: Victim started\n");
for (; ; )
{
sleep(3);
printf("victim_main: Wasting time\n" );
printf("victim_main: Wasting time\n");
FFLUSH();
}
return 0; /* Won't get here */
}
/****************************************************************************
* Public Functions
****************************************************************************/
void suspend_test(void)
{
struct sched_param param;
@ -58,11 +58,11 @@ void suspend_test(void)
/* Start victim thread */
printf("suspend_test: Starting victim task\n" );
printf("suspend_test: Starting victim task\n");
ret = sched_getparam (0, &param);
if (ret < 0)
{
printf("suspend_test: ERROR sched_getparam() failed\n" );
printf("suspend_test: ERROR sched_getparam() failed\n");
param.sched_priority = PTHREAD_DEFAULT_PRIORITY;
}
@ -70,7 +70,7 @@ void suspend_test(void)
STACKSIZE, victim_main, NULL);
if (victim == ERROR)
{
printf("suspend_test: ERROR failed to start victim_main\n" );
printf("suspend_test: ERROR failed to start victim_main\n");
}
else
{
@ -89,7 +89,7 @@ void suspend_test(void)
ret = kill(victim, SIGSTOP);
if (ret < 0)
{
printf("suspend_test: ERROR kill() failed\n" );
printf("suspend_test: ERROR kill() failed\n");
}
printf("suspend_test: Is the victim still jabbering?\n");
@ -100,7 +100,7 @@ void suspend_test(void)
ret = kill(victim, SIGCONT);
if (ret < 0)
{
printf("suspend_test: ERROR kill() failed\n" );
printf("suspend_test: ERROR kill() failed\n");
}
printf("suspend_test: The victim should continue the rant.\n");
@ -111,7 +111,7 @@ void suspend_test(void)
ret = kill(victim, SIGKILL);
if (ret < 0)
{
printf("suspend_test: ERROR kill() failed\n" );
printf("suspend_test: ERROR kill() failed\n");
}
FFLUSH();
@ -119,9 +119,9 @@ void suspend_test(void)
ret = kill(victim, 0);
if (ret >= 0)
{
printf("suspend_test: ERROR kill() on the dead victim succeeded!\n" );
printf("suspend_test: ERROR kill() on the dead victim succeeded!\n");
}
printf("suspend_test: done\n" );
printf("suspend_test: done\n");
FFLUSH();
}

2
testing/ostest/timedmqueue.c
View File

@ -1,5 +1,5 @@
/****************************************************************************
* apps/testing/ostest/mqueue.c
* apps/testing/ostest/timedmqueue.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with

35
testing/ostest/timedwait.c
View File

@ -56,7 +56,8 @@ static void *thread_waiter(void *parameter)
status = pthread_mutex_lock(&mutex);
if (status != 0)
{
printf("thread_waiter: ERROR pthread_mutex_lock failed, status=%d\n", status);
printf("thread_waiter: ERROR pthread_mutex_lock failed, status=%d\n",
status);
}
printf("thread_waiter: Starting 5 second wait for condition\n");
@ -66,6 +67,7 @@ static void *thread_waiter(void *parameter)
{
printf("thread_waiter: ERROR clock_gettime failed\n");
}
ts.tv_sec += 5;
/* The wait -- no-one is ever going to awaken us */
@ -79,12 +81,15 @@ static void *thread_waiter(void *parameter)
}
else
{
printf("thread_waiter: ERROR pthread_cond_timedwait failed, status=%d\n", status);
printf("thread_waiter: "
"ERROR pthread_cond_timedwait failed, status=%d\n", status);
}
}
else
{
printf("thread_waiter: ERROR pthread_cond_timedwait returned without timeout, status=%d\n", status);
printf("thread_waiter: ERROR "
"pthread_cond_timedwait returned without timeout, status=%d\n",
status);
}
/* Release the mutex */
@ -93,7 +98,8 @@ static void *thread_waiter(void *parameter)
status = pthread_mutex_unlock(&mutex);
if (status != 0)
{
printf("thread_waiter: ERROR pthread_mutex_unlock failed, status=%d\n", status);
printf("thread_waiter: ERROR pthread_mutex_unlock failed, status=%d\n",
status);
}
printf("thread_waiter: Exit with status 0x12345678\n");
@ -120,7 +126,8 @@ void timedwait_test(void)
status = pthread_mutex_init(&mutex, NULL);
if (status != 0)
{
printf("timedwait_test: ERROR pthread_mutex_init failed, status=%d\n", status);
printf("timedwait_test: ERROR pthread_mutex_init failed, status=%d\n",
status);
}
/* Initialize the condition variable */
@ -129,7 +136,8 @@ void timedwait_test(void)
status = pthread_cond_init(&cond, NULL);
if (status != 0)
{
printf("timedwait_test: ERROR pthread_condinit failed, status=%d\n", status);
printf("timedwait_test: ERROR pthread_condinit failed, status=%d\n",
status);
}
/* Start the waiter thread at higher priority */
@ -138,7 +146,8 @@ void timedwait_test(void)
status = pthread_attr_init(&attr);
if (status != 0)
{
printf("timedwait_test: pthread_attr_init failed, status=%d\n", status);
printf("timedwait_test: pthread_attr_init failed, status=%d\n",
status);
}
prio_max = sched_get_priority_max(SCHED_FIFO);
@ -150,14 +159,17 @@ void timedwait_test(void)
}
sparam.sched_priority = (prio_max + sparam.sched_priority) / 2;
status = pthread_attr_setschedparam(&attr,&sparam);
status = pthread_attr_setschedparam(&attr, &sparam);
if (status != OK)
{
printf("timedwait_test: pthread_attr_setschedparam failed, status=%d\n", status);
printf("timedwait_test: "
"pthread_attr_setschedparam failed, status=%d\n",
status);
}
else
{
printf("timedwait_test: Set thread 2 priority to %d\n", sparam.sched_priority);
printf("timedwait_test: Set thread 2 priority to %d\n",
sparam.sched_priority);
}
status = pthread_create(&waiter, &attr, thread_waiter, NULL);
@ -171,7 +183,8 @@ void timedwait_test(void)
status = pthread_join(waiter, &result);
if (status != 0)
{
printf("timedwait_test: ERROR pthread_join failed, status=%d\n", status);
printf("timedwait_test: ERROR pthread_join failed, status=%d\n",
status);
}
else
{

122
testing/ostest/waitpid.c
View File

@ -58,7 +58,8 @@ static int waitpid_main(int argc, char *argv[])
printf("waitpid_main: PID %d Started\n", me);
sleep(3);
printf("waitpid_main: PID %d exitting with result=%d\n", me, RETURN_STATUS);
printf("waitpid_main: PID %d exitting with result=%d\n",
me, RETURN_STATUS);
return RETURN_STATUS;
}
@ -72,11 +73,13 @@ static void waitpid_start_children(void)
ret = task_create("waitpid", PRIORITY, STACKSIZE, waitpid_main, NULL);
if (ret < 0)
{
printf("waitpid_start_child: ERROR Failed to start waitpid_main\n");
printf("waitpid_start_child: "
"ERROR Failed to start waitpid_main\n");
}
else
{
printf("waitpid_start_child: Started waitpid_main at PID=%d\n", ret);
printf("waitpid_start_child: "
"Started waitpid_main at PID=%d\n", ret);
}
g_waitpids[i] = ret;
@ -92,7 +95,7 @@ static void waitpid_last(void)
/* Find the last child thread that was started successfully */
for (i = NCHILDREN-1; i > 0; i--)
for (i = NCHILDREN - 1; i > 0; i--)
{
if (g_waitpids[i] >= 0)
{
@ -110,39 +113,46 @@ static void waitpid_last(void)
}
printf("waitpid_last: Waiting for PID=%d with waitpid()\n",
g_waitpids[NCHILDREN-1]);
g_waitpids[NCHILDREN - 1]);
ret = (int)waitpid(g_waitpids[NCHILDREN-1], &stat_loc, 0);
ret = (int)waitpid(g_waitpids[NCHILDREN - 1], &stat_loc, 0);
if (ret < 0)
{
int errcode = errno;
/* Unfortunately, this main thread does not retain child status. If
* child status is enabled (via CONFIG_SCHED_CHILD_STATUS), ostest_main()
* disables the feature by calling sigactin with SA_NOCLDWAIT.
/* Unfortunately, this main thread does not retain child status.
* If child status is enabled (via CONFIG_SCHED_CHILD_STATUS),
* ostest_main() disables the feature by calling sigactin with
* SA_NOCLDWAIT.
*/
if (errcode == ECHILD)
{
printf("waitpid_last: PASS: PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN-1]);
printf(" acceptable because child status is disabled on this thread.\n");
printf("waitpid_last: PASS: "
"PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN - 1]);
printf(" acceptable "
"because child status is disabled on this thread.\n");
}
else
{
printf("waitpid_last: ERROR: PID %d waitpid failed: %d\n",
g_waitpids[NCHILDREN-1], errcode);
g_waitpids[NCHILDREN - 1], errcode);
}
}
else if (WEXITSTATUS(stat_loc) != RETURN_STATUS)
{
printf("waitpid_last: ERROR: PID %d return status is %d, expected %d\n",
g_waitpids[NCHILDREN-1], WEXITSTATUS(stat_loc), RETURN_STATUS);
printf("waitpid_last: ERROR: "
"PID %d return status is %d, expected %d\n",
g_waitpids[NCHILDREN - 1],
WEXITSTATUS(stat_loc),
RETURN_STATUS);
}
else
{
printf("waitpid_last: PASS: PID %d waitpid succeeded with stat_loc=%04x\n",
g_waitpids[NCHILDREN-1], stat_loc);
printf("waitpid_last: PASS: "
"PID %d waitpid succeeded with stat_loc=%04x\n",
g_waitpids[NCHILDREN - 1], stat_loc);
}
}
@ -163,22 +173,26 @@ int waitpid_test(void)
printf("\nTest waitpid()\n");
waitpid_start_children();
printf("waitpid_test: Waiting for PID=%d with waitpid()\n", g_waitpids[0]);
printf("waitpid_test: Waiting for PID=%d with waitpid()\n",
g_waitpids[0]);
ret = (int)waitpid(g_waitpids[0], &stat_loc, 0);
if (ret < 0)
{
int errcode = errno;
/* Unfortunately, this main thread does not retain child status. If
* child status is enabled (via CONFIG_SCHED_CHILD_STATUS), ostest_main()
* disables the feature by calling sigactin with SA_NOCLDWAIT.
/* Unfortunately, this main thread does not retain child status.
* If child status is enabled (via CONFIG_SCHED_CHILD_STATUS),
* ostest_main() disables the feature by calling sigactin with
* SA_NOCLDWAIT.
*/
if (errcode == ECHILD)
{
printf("waitpid_test: PASS: PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN-1]);
printf(" acceptable because child status is disabled on this thread.\n");
printf("waitpid_test: PASS: "
"PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN - 1]);
printf(" acceptable "
"because child status is disabled on this thread.\n");
}
else
{
@ -193,12 +207,14 @@ int waitpid_test(void)
}
else if (WEXITSTATUS(stat_loc) != RETURN_STATUS)
{
printf("waitpid_test: ERROR: PID %d return status is %d, expected %d\n",
printf("waitpid_test: ERROR: "
"PID %d return status is %d, expected %d\n",
g_waitpids[0], WEXITSTATUS(stat_loc), RETURN_STATUS);
}
else
{
printf("waitpid_test: PID %d waitpid succeeded with stat_loc=%04x\n",
printf("waitpid_test: "
"PID %d waitpid succeeded with stat_loc=%04x\n",
g_waitpids[0], stat_loc);
}
@ -219,16 +235,19 @@ int waitpid_test(void)
{
int errcode = errno;
/* Unfortunately, this main thread does not retain child status. If
* child status is enabled (via CONFIG_SCHED_CHILD_STATUS), ostest_main()
* disables the feature by calling sigactin with SA_NOCLDWAIT.
/* Unfortunately, this main thread does not retain child status.
* If child status is enabled (via CONFIG_SCHED_CHILD_STATUS),
* ostest_main() disables the feature by calling sigactin with
* SA_NOCLDWAIT.
*/
if (errcode == ECHILD)
{
printf("waitpid_test: PASS: PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN-1]);
printf(" acceptable because child status is disabled on this thread.\n");
printf("waitpid_test: PASS: "
"PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN - 1]);
printf(" acceptable "
"because child status is disabled on this thread.\n");
}
else
{
@ -243,7 +262,8 @@ int waitpid_test(void)
}
else if (info.si_status != RETURN_STATUS)
{
printf("waitpid_test: ERROR: PID %d return status is %d, expected %d\n",
printf("waitpid_test: ERROR: "
"PID %d return status is %d, expected %d\n",
info.si_pid, info.si_status, RETURN_STATUS);
}
else
@ -268,16 +288,19 @@ int waitpid_test(void)
{
int errcode = errno;
/* Unfortunately, this main thread does not retain child status. If
* child status is enabled (via CONFIG_SCHED_CHILD_STATUS), ostest_main()
* disables the feature by calling sigactin with SA_NOCLDWAIT.
/* Unfortunately, this main thread does not retain child status.
* If child status is enabled (via CONFIG_SCHED_CHILD_STATUS),
* ostest_main() disables the feature by calling sigactin with
* SA_NOCLDWAIT.
*/
if (errcode == ECHILD)
{
printf("waitpid_test: PASS: PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN-1]);
printf(" acceptable because child status is disabled on this thread.\n");
printf("waitpid_test: PASS: "
"PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN - 1]);
printf(" acceptable "
"because child status is disabled on this thread.\n");
}
else
{
@ -286,7 +309,8 @@ int waitpid_test(void)
}
else if (info.si_status != RETURN_STATUS)
{
printf("waitpid_test: ERROR: PID %d return status is %d, expected %d\n",
printf("waitpid_test: ERROR: "
"PID %d return status is %d, expected %d\n",
info.si_pid, info.si_status, RETURN_STATUS);
}
else
@ -311,16 +335,19 @@ int waitpid_test(void)
{
int errcode = errno;
/* Unfortunately, this main thread does not retain child status. If
* child status is enabled (via CONFIG_SCHED_CHILD_STATUS), ostest_main()
* disables the feature by calling sigactin with SA_NOCLDWAIT.
/* Unfortunately, this main thread does not retain child status.
* If child status is enabled (via CONFIG_SCHED_CHILD_STATUS),
* ostest_main() disables the feature by calling sigactin with
* SA_NOCLDWAIT.
*/
if (errcode == ECHILD)
{
printf("waitpid_test: PASS: PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN-1]);
printf(" acceptable because child status is disabled on this thread.\n");
printf("waitpid_test: PASS: "
"PID %d waitpid failed with ECHILD. That may be\n",
g_waitpids[NCHILDREN - 1]);
printf(" acceptable "
"because child status is disabled on this thread.\n");
}
else
{
@ -329,7 +356,8 @@ int waitpid_test(void)
}
else if (WEXITSTATUS(stat_loc) != RETURN_STATUS)
{
printf("waitpid_test: ERROR: PID %d return status is %d, expected %d\n",
printf("waitpid_test: ERROR: "
"PID %d return status is %d, expected %d\n",
ret, WEXITSTATUS(stat_loc), RETURN_STATUS);
}
else