diff options
Diffstat (limited to 'testsuite')
| -rw-r--r-- | testsuite/condvar01/test_main.c | 396 | ||||
| -rw-r--r-- | testsuite/mutex01/test_main.c | 520 | ||||
| -rw-r--r-- | testsuite/rwlock01/test_main.c | 6 |
3 files changed, 916 insertions, 6 deletions
diff --git a/testsuite/condvar01/test_main.c b/testsuite/condvar01/test_main.c new file mode 100644 index 00000000..53c98152 --- /dev/null +++ b/testsuite/condvar01/test_main.c @@ -0,0 +1,396 @@ +/* + * Copyright (c) 2014 embedded brains GmbH. All rights reserved. + * + * embedded brains GmbH + * Dornierstr. 4 + * 82178 Puchheim + * Germany + * <rtems@embedded-brains.de> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <rtems/bsd/sys/param.h> +#include <rtems/bsd/sys/types.h> +#include <sys/systm.h> +#include <rtems/bsd/sys/lock.h> +#include <sys/mutex.h> +#include <sys/condvar.h> + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <rtems/libcsupport.h> +#include <rtems.h> + +#define TEST_NAME "LIBBSD CONDVAR 1" + +#define PRIO_MASTER 3 + +#define EVENT_LOCK RTEMS_EVENT_0 + +#define EVENT_UNLOCK RTEMS_EVENT_1 + +#define EVENT_WAIT RTEMS_EVENT_2 + +#define EVENT_WAIT_SIG RTEMS_EVENT_3 + +#define EVENT_WAIT_UNLOCK RTEMS_EVENT_4 + +#define EVENT_TIMEDWAIT RTEMS_EVENT_5 + +#define EVENT_TIMEDWAIT_SIG RTEMS_EVENT_6 + +#define WORKER_COUNT 2 + +typedef struct { + struct mtx mtx; + struct cv cv; + int rv; + int timo; + rtems_id worker_task[WORKER_COUNT]; + bool done[WORKER_COUNT]; +} test_context; + +static test_context test_instance; + +static const rtems_task_priority prio_worker[2] = { 2, 1 }; + +static void +set_self_prio(rtems_task_priority prio) +{ + rtems_status_code sc; + + sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio); + assert(sc == RTEMS_SUCCESSFUL); +} + +static void +worker_task(rtems_task_argument index) +{ + test_context *ctx = &test_instance; + struct mtx *mtx = &ctx->mtx; + struct cv *cv = &ctx->cv; + + while (true) { + rtems_status_code sc; + rtems_event_set events; + + sc = rtems_event_receive( + RTEMS_ALL_EVENTS, + RTEMS_EVENT_ANY | RTEMS_WAIT, + RTEMS_NO_TIMEOUT, + &events + ); + assert(sc == RTEMS_SUCCESSFUL); + + if ((events & EVENT_LOCK) != 0) { + mtx_lock(mtx); + ctx->done[index] = true; + } + + if ((events & EVENT_UNLOCK) != 0) { + mtx_unlock(mtx); + ctx->done[index] = true; + } + + if ((events & EVENT_WAIT) != 0) { + cv_wait(cv, mtx); + ctx->done[index] = true; + } + + if ((events & EVENT_WAIT_SIG) != 0) { + int rv = cv_wait_sig(cv, mtx); + assert(rv == 0); + ctx->done[index] = true; + } + + if ((events & EVENT_WAIT_UNLOCK) != 0) { + cv_wait_unlock(cv, mtx); + ctx->done[index] = true; + } + + if ((events & EVENT_TIMEDWAIT) != 0) { + ctx->rv = cv_timedwait(cv, mtx, ctx->timo); + ctx->done[index] = true; + } + + if ((events & EVENT_TIMEDWAIT_SIG) != 0) { + ctx->rv = cv_timedwait_sig(cv, mtx, ctx->timo); + ctx->done[index] = true; + } + } +} + +static void +send_events(test_context *ctx, rtems_event_set events, size_t index) +{ + rtems_status_code sc; + + sc = rtems_event_send(ctx->worker_task[index], events); + assert(sc == RTEMS_SUCCESSFUL); +} + +static void +start_worker(test_context *ctx) +{ + size_t i; + + for (i = 0; i < WORKER_COUNT; ++i) { + rtems_status_code sc; + + sc = rtems_task_create( + rtems_build_name('W', 'O', 'R', 'K'), + prio_worker[i], + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_MODES, + RTEMS_FLOATING_POINT, + &ctx->worker_task[i] + ); + assert(sc == RTEMS_SUCCESSFUL); + + sc = rtems_task_start( + ctx->worker_task[i], + worker_task, + i + ); + assert(sc == RTEMS_SUCCESSFUL); + } +} + +static void +delete_worker(test_context *ctx) +{ + size_t i; + + for (i = 0; i < WORKER_COUNT; ++i) { + rtems_status_code sc; + + sc = rtems_task_delete(ctx->worker_task[i]); + assert(sc == RTEMS_SUCCESSFUL); + } +} + +static void +test_cv_wait_signal(test_context *ctx, rtems_event_set event, const char *name) +{ + struct mtx *mtx = &ctx->mtx; + struct cv *cv = &ctx->cv; + size_t low = 0; + size_t high = 1; + + printf("test cv %s signal\n", name); + + mtx_lock(mtx); + mtx_unlock(mtx); + + ctx->timo = 0; + + ctx->done[low] = false; + send_events(ctx, EVENT_LOCK, low); + assert(ctx->done[low]); + + ctx->done[high] = false; + send_events(ctx, EVENT_LOCK, high); + assert(!ctx->done[high]); + + ctx->done[low] = false; + send_events(ctx, event, low); + assert(!ctx->done[low]); + assert(ctx->done[high]); + + ctx->done[low] = false; + ctx->done[high] = false; + send_events(ctx, event, high); + assert(!ctx->done[low]); + assert(!ctx->done[high]); + + cv_signal(cv); + assert(!ctx->done[low]); + assert(ctx->done[high]); + + if (event != EVENT_WAIT_UNLOCK) { + cv_signal(cv); + assert(!ctx->done[low]); + + ctx->done[high] = false; + send_events(ctx, EVENT_UNLOCK, high); + assert(ctx->done[high]); + assert(ctx->done[low]); + + ctx->done[low] = false; + send_events(ctx, EVENT_UNLOCK, low); + assert(ctx->done[low]); + } else { + cv_signal(cv); + assert(ctx->done[low]); + } + + mtx_lock(mtx); + mtx_unlock(mtx); +} + +static void +test_cv_wait_broadcast(test_context *ctx, rtems_event_set event, const char *name) +{ + struct mtx *mtx = &ctx->mtx; + struct cv *cv = &ctx->cv; + size_t low = 0; + size_t high = 1; + + printf("test cv %s broadcast\n", name); + + mtx_lock(mtx); + mtx_unlock(mtx); + + ctx->timo = 0; + + ctx->done[low] = false; + send_events(ctx, EVENT_LOCK, low); + assert(ctx->done[low]); + + ctx->done[high] = false; + send_events(ctx, EVENT_LOCK, high); + assert(!ctx->done[high]); + + ctx->done[low] = false; + send_events(ctx, event, low); + assert(!ctx->done[low]); + assert(ctx->done[high]); + + ctx->done[low] = false; + ctx->done[high] = false; + send_events(ctx, event, high); + assert(!ctx->done[low]); + assert(!ctx->done[high]); + + if (event != EVENT_WAIT_UNLOCK) { + cv_broadcast(cv); + assert(!ctx->done[low]); + + ctx->done[high] = false; + send_events(ctx, EVENT_UNLOCK, high); + assert(ctx->done[high]); + assert(ctx->done[low]); + + ctx->done[low] = false; + send_events(ctx, EVENT_UNLOCK, low); + assert(ctx->done[low]); + } else { + cv_broadcast(cv); + assert(ctx->done[low]); + assert(ctx->done[high]); + } + + mtx_lock(mtx); + mtx_unlock(mtx); +} + +static void +test_cv_wait(test_context *ctx, rtems_event_set event, const char *name) +{ + test_cv_wait_signal(ctx, event, name); + test_cv_wait_broadcast(ctx, event, name); +} + +static void +test_cv_wait_timeout(test_context *ctx) +{ + size_t index = 0; + rtems_status_code sc; + + puts("test cv wait timeout"); + + ctx->timo = 2; + + ctx->done[index] = false; + send_events(ctx, EVENT_LOCK, index); + assert(ctx->done[index]); + + ctx->done[index] = false; + ctx->rv = 0; + send_events(ctx, EVENT_TIMEDWAIT, index); + assert(!ctx->done[index]); + + sc = rtems_task_wake_after(ctx->timo); + assert(sc == RTEMS_SUCCESSFUL); + assert(ctx->done[index]); + assert(ctx->rv == EWOULDBLOCK); + + ctx->done[index] = false; + ctx->rv = 0; + send_events(ctx, EVENT_TIMEDWAIT_SIG, index); + assert(!ctx->done[index]); + + sc = rtems_task_wake_after(ctx->timo); + assert(sc == RTEMS_SUCCESSFUL); + assert(ctx->done[index]); + assert(ctx->rv == EWOULDBLOCK); + + ctx->done[index] = false; + send_events(ctx, EVENT_UNLOCK, index); + assert(ctx->done[index]); +} + +static void +alloc_basic_resources(void) +{ + curthread; +} + +static void +test_main(void) +{ + test_context *ctx = &test_instance; + rtems_resource_snapshot snapshot; + + alloc_basic_resources(); + + rtems_resource_snapshot_take(&snapshot); + + cv_init(&ctx->cv, "test"); + assert(strcmp(cv_wmesg(&ctx->cv), "test") == 0); + + set_self_prio(PRIO_MASTER); + start_worker(ctx); + + test_cv_wait(ctx, EVENT_WAIT, "wait"); + test_cv_wait(ctx, EVENT_WAIT_SIG, "wait sig"); + test_cv_wait(ctx, EVENT_WAIT_UNLOCK, "wait unlock"); + test_cv_wait(ctx, EVENT_TIMEDWAIT, "timed wait"); + test_cv_wait(ctx, EVENT_TIMEDWAIT_SIG, "timed wait sig"); + + test_cv_wait_timeout(ctx); + + delete_worker(ctx); + cv_destroy(&ctx->cv); + + assert(rtems_resource_snapshot_check(&snapshot)); + + exit(0); +} + +#include <rtems/bsd/test/default-init.h> diff --git a/testsuite/mutex01/test_main.c b/testsuite/mutex01/test_main.c new file mode 100644 index 00000000..504d80af --- /dev/null +++ b/testsuite/mutex01/test_main.c @@ -0,0 +1,520 @@ +/* + * Copyright (c) 2014 embedded brains GmbH. All rights reserved. + * + * embedded brains GmbH + * Dornierstr. 4 + * 82178 Puchheim + * Germany + * <rtems@embedded-brains.de> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <rtems/bsd/sys/param.h> +#include <rtems/bsd/sys/types.h> +#include <sys/systm.h> +#include <rtems/bsd/sys/lock.h> +#include <sys/mutex.h> + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <rtems/libcsupport.h> +#include <rtems.h> + +#define TEST_NAME "LIBBSD MUTEX 1" + +#define PRIO_MASTER 3 + +#define EVENT_LOCK RTEMS_EVENT_0 + +#define EVENT_TRY_LOCK RTEMS_EVENT_1 + +#define EVENT_UNLOCK RTEMS_EVENT_2 + +#define EVENT_SLEEP RTEMS_EVENT_3 + +#define WORKER_COUNT 2 + +typedef struct { + struct mtx mtx; + struct mtx mtx2; + int rv; + int timo; + rtems_id worker_task[WORKER_COUNT]; + bool done[WORKER_COUNT]; +} test_context; + +static test_context test_instance; + +static const rtems_task_priority prio_worker[2] = { 2, 1 }; + +static void +set_self_prio(rtems_task_priority prio) +{ + rtems_status_code sc; + + sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio); + assert(sc == RTEMS_SUCCESSFUL); +} + +static rtems_task_priority +get_self_prio(void) +{ + rtems_status_code sc; + rtems_task_priority prio; + + sc = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &prio); + assert(sc == RTEMS_SUCCESSFUL); + + return prio; +} + +static void +worker_task(rtems_task_argument index) +{ + test_context *ctx = &test_instance; + struct mtx *mtx = &ctx->mtx; + + while (true) { + rtems_status_code sc; + rtems_event_set events; + + sc = rtems_event_receive( + RTEMS_ALL_EVENTS, + RTEMS_EVENT_ANY | RTEMS_WAIT, + RTEMS_NO_TIMEOUT, + &events + ); + assert(sc == RTEMS_SUCCESSFUL); + + if ((events & EVENT_LOCK) != 0) { + mtx_lock(mtx); + ctx->done[index] = true; + } + + if ((events & EVENT_TRY_LOCK) != 0) { + ctx->rv = mtx_trylock(mtx); + ctx->done[index] = true; + } + + if ((events & EVENT_UNLOCK) != 0) { + mtx_unlock(mtx); + ctx->done[index] = true; + } + + if ((events & EVENT_SLEEP) != 0) { + ctx->rv = mtx_sleep(ctx, mtx, 0, "worker", ctx->timo); + ctx->done[index] = true; + } + } +} + +static void +send_events(test_context *ctx, rtems_event_set events, size_t index) +{ + rtems_status_code sc; + + sc = rtems_event_send(ctx->worker_task[index], events); + assert(sc == RTEMS_SUCCESSFUL); +} + +static void +start_worker(test_context *ctx) +{ + size_t i; + + for (i = 0; i < WORKER_COUNT; ++i) { + rtems_status_code sc; + + sc = rtems_task_create( + rtems_build_name('W', 'O', 'R', 'K'), + prio_worker[i], + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_MODES, + RTEMS_FLOATING_POINT, + &ctx->worker_task[i] + ); + assert(sc == RTEMS_SUCCESSFUL); + + sc = rtems_task_start( + ctx->worker_task[i], + worker_task, + i + ); + assert(sc == RTEMS_SUCCESSFUL); + } +} + +static void +delete_worker(test_context *ctx) +{ + size_t i; + + for (i = 0; i < WORKER_COUNT; ++i) { + rtems_status_code sc; + + sc = rtems_task_delete(ctx->worker_task[i]); + assert(sc == RTEMS_SUCCESSFUL); + } +} + +static void +test_mtx_non_recursive(test_context *ctx) +{ + struct mtx *mtx = &ctx->mtx; + + puts("test mtx non-recursive"); + + assert(!mtx_initialized(mtx)); + mtx_init(mtx, "test", NULL, MTX_DEF); + assert(mtx_initialized(mtx)); + + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_lock(mtx); + + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + mtx_unlock(mtx); + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + mtx_destroy(mtx); + assert(!mtx_initialized(mtx)); +} + +static void +test_mtx_recursive(test_context *ctx) +{ + struct mtx *mtx = &ctx->mtx; + + puts("test mtx recursive"); + + assert(!mtx_initialized(mtx)); + mtx_init(mtx, "test", NULL, MTX_DEF | MTX_RECURSE); + assert(mtx_initialized(mtx)); + + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_lock(mtx); + + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_lock(mtx); + + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 1); + mtx_lock(mtx); + + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 2); + + mtx_unlock(mtx); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 1); + + mtx_unlock(mtx); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + mtx_unlock(mtx); + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + mtx_destroy(mtx); + assert(!mtx_initialized(mtx)); +} + +static void +test_mtx_trylock(test_context *ctx) +{ + size_t index = 0; + struct mtx *mtx = &ctx->mtx; + int ok; + + puts("test mtx try lock"); + + assert(!mtx_initialized(mtx)); + mtx_init(mtx, "test", NULL, MTX_DEF); + assert(mtx_initialized(mtx)); + + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + ok = mtx_trylock(mtx); + assert(ok != 0); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + mtx_unlock(mtx); + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_lock(mtx); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + ctx->done[index] = false; + ctx->rv = 1; + send_events(ctx, EVENT_TRY_LOCK, index); + assert(ctx->done[index]); + assert(ctx->rv == 0); + + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_unlock(mtx); + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + mtx_destroy(mtx); + assert(!mtx_initialized(mtx)); +} + +static void +test_mtx_lock(test_context *ctx) +{ + struct mtx *mtx = &ctx->mtx; + struct mtx *mtx2 = &ctx->mtx2; + size_t low = 0; + size_t high = 1; + + puts("test mtx lock"); + + assert(!mtx_initialized(mtx)); + mtx_init(mtx, "test", NULL, MTX_DEF); + assert(mtx_initialized(mtx)); + + assert(!mtx_initialized(mtx2)); + mtx_init(mtx2, "test 2", NULL, MTX_DEF); + assert(mtx_initialized(mtx2)); + + /* Resource count one */ + + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_lock(mtx); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + assert(get_self_prio() == PRIO_MASTER); + + ctx->done[low] = false; + ctx->done[high] = false; + + send_events(ctx, EVENT_LOCK, low); + assert(!ctx->done[low]); + assert(!ctx->done[high]); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + assert(get_self_prio() == prio_worker[low]); + + send_events(ctx, EVENT_LOCK, high); + assert(!ctx->done[low]); + assert(!ctx->done[high]); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + assert(get_self_prio() == prio_worker[high]); + + mtx_unlock(mtx); + assert(!ctx->done[low]); + assert(ctx->done[high]); + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + assert(get_self_prio() == PRIO_MASTER); + + ctx->done[high] = false; + send_events(ctx, EVENT_UNLOCK, high); + assert(ctx->done[low]); + assert(ctx->done[high]); + + ctx->done[low] = false; + send_events(ctx, EVENT_UNLOCK, low); + assert(ctx->done[low]); + + /* Resource count two */ + + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_lock(mtx); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + assert(get_self_prio() == PRIO_MASTER); + + assert(!mtx_owned(mtx2)); + assert(mtx_recursed(mtx2) == 0); + mtx_lock(mtx2); + assert(mtx_owned(mtx2)); + assert(mtx_recursed(mtx2) == 0); + assert(get_self_prio() == PRIO_MASTER); + + ctx->done[low] = false; + send_events(ctx, EVENT_LOCK, low); + assert(!ctx->done[low]); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + assert(get_self_prio() == prio_worker[low]); + + mtx_unlock(mtx2); + assert(!mtx_owned(mtx2)); + assert(mtx_recursed(mtx2) == 0); + assert(get_self_prio() == prio_worker[low]); + + mtx_unlock(mtx); + assert(ctx->done[low]); + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + assert(get_self_prio() == PRIO_MASTER); + + ctx->done[low] = false; + send_events(ctx, EVENT_UNLOCK, low); + assert(ctx->done[low]); + + mtx_destroy(mtx2); + assert(!mtx_initialized(mtx2)); + + mtx_destroy(mtx); + assert(!mtx_initialized(mtx)); +} + +static void +test_mtx_sleep_with_lock(test_context *ctx) +{ + size_t index = 0; + struct mtx *mtx = &ctx->mtx; + + puts("test mtx sleep with lock"); + + assert(!mtx_initialized(mtx)); + mtx_init(mtx, "test", NULL, MTX_DEF); + assert(mtx_initialized(mtx)); + + ctx->done[index] = false; + send_events(ctx, EVENT_LOCK, index); + assert(ctx->done[index]); + + ctx->done[index] = false; + ctx->timo = 0; + send_events(ctx, EVENT_SLEEP, index); + assert(!ctx->done[index]); + + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + mtx_lock(mtx); + assert(mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + wakeup(ctx); + assert(!ctx->done[index]); + + mtx_unlock(mtx); + assert(ctx->done[index]); + assert(!mtx_owned(mtx)); + assert(mtx_recursed(mtx) == 0); + + ctx->done[index] = false; + send_events(ctx, EVENT_UNLOCK, index); + assert(ctx->done[index]); + + mtx_destroy(mtx); + assert(!mtx_initialized(mtx)); +} + +static void +test_mtx_sleep_timeout(test_context *ctx) +{ + size_t index = 0; + struct mtx *mtx = &ctx->mtx; + rtems_status_code sc; + + puts("test mtx sleep timeout"); + + assert(!mtx_initialized(mtx)); + mtx_init(mtx, "test", NULL, MTX_DEF); + assert(mtx_initialized(mtx)); + + ctx->done[index] = false; + send_events(ctx, EVENT_LOCK, index); + assert(ctx->done[index]); + + ctx->done[index] = false; + ctx->timo = 2; + send_events(ctx, EVENT_SLEEP, index); + assert(!ctx->done[index]); + + sc = rtems_task_wake_after(ctx->timo); + assert(sc == RTEMS_SUCCESSFUL); + assert(ctx->done[index]); + + ctx->done[index] = false; + send_events(ctx, EVENT_UNLOCK, index); + assert(ctx->done[index]); + + mtx_destroy(mtx); + assert(!mtx_initialized(mtx)); +} + +static void +alloc_basic_resources(void) +{ + curthread; +} + +static void +test_main(void) +{ + test_context *ctx = &test_instance; + rtems_resource_snapshot snapshot_0; + rtems_resource_snapshot snapshot_1; + + alloc_basic_resources(); + + rtems_resource_snapshot_take(&snapshot_0); + + set_self_prio(PRIO_MASTER); + start_worker(ctx); + + rtems_resource_snapshot_take(&snapshot_1); + + test_mtx_non_recursive(ctx); + test_mtx_recursive(ctx); + test_mtx_trylock(ctx); + test_mtx_lock(ctx); + + assert(rtems_resource_snapshot_check(&snapshot_1)); + + test_mtx_sleep_with_lock(ctx); + test_mtx_sleep_timeout(ctx); + + delete_worker(ctx); + + assert(rtems_resource_snapshot_check(&snapshot_0)); + + exit(0); +} + +#include <rtems/bsd/test/default-init.h> diff --git a/testsuite/rwlock01/test_main.c b/testsuite/rwlock01/test_main.c index fc4b2694..3e121c38 100644 --- a/testsuite/rwlock01/test_main.c +++ b/testsuite/rwlock01/test_main.c @@ -188,9 +188,6 @@ test_rw_non_recursive(test_context *ctx) rw_rlock(rw); /* FIXME: We use a mutex implementation */ assert(rw_wowned(rw)); - /* FIXME: We always allow recursion */ - rw_rlock(rw); - rw_runlock(rw); rw_runlock(rw); rw_rlock(rw); @@ -228,9 +225,6 @@ test_rw_non_recursive(test_context *ctx) rw_wlock(rw); assert(rw_wowned(rw)); - /* FIXME: We always allow recursion */ - rw_wlock(rw); - rw_wunlock(rw); rw_wunlock(rw); rw_wlock(rw); |