From 97817eb7dcdc881e05e1d46c125a7f8db6b111d1 Mon Sep 17 00:00:00 2001 From: gdisirio Date: Sun, 12 Apr 2009 13:00:42 +0000 Subject: Added more test cases. git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@896 35acf78f-673a-0410-8e92-d51de3d6d3f4 --- readme.txt | 4 +- test/test.c | 6 ++- test/testmtx.c | 143 ++++++++++++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 128 insertions(+), 25 deletions(-) diff --git a/readme.txt b/readme.txt index efd4be871..87728bdfa 100644 --- a/readme.txt +++ b/readme.txt @@ -84,8 +84,8 @@ Win32-MinGW - ChibiOS/RT simulator and demo into a WIN32 process, - FIX: Removed usused list functions (bug 2755230)(backported in stable branch). - NEW: Added a code coverage analysis application under ./tests/coverage. - Currently the test suite explicitly covers about 74% of the kernel code, - it is not bad as a starting point. +- Added more test cases in order to improve code coverage (it was 74% in + version 1.2.0). *** 1.2.0 *** - Added license exception text to the 1.2.0 branch. diff --git a/test/test.c b/test/test.c index 887d56ecc..5cc11f542 100644 --- a/test/test.c +++ b/test/test.c @@ -164,8 +164,10 @@ void test_wait_threads(void) { int i; for (i = 0; i < MAX_THREADS; i++) - if (threads[i]) + if (threads[i] != NULL) { chThdWait(threads[i]); + threads[i] = NULL; + } } void test_cpu_pulse(unsigned ms) { @@ -222,6 +224,8 @@ static void execute_test(const struct testcase *tcp) { tcp->execute(); if (tcp->teardown != NULL) tcp->teardown(); + + test_wait_threads(); } msg_t TestThread(void *p) { diff --git a/test/testmtx.c b/test/testmtx.c index c8050e887..feaeb2338 100644 --- a/test/testmtx.c +++ b/test/testmtx.c @@ -214,14 +214,111 @@ const struct testcase testmtx3 = { mtx3_execute }; -#if CH_USE_CONDVARS static char *mtx4_gettest(void) { - return "CondVar, signal test"; + return "Mutexes, priority return"; } static void mtx4_setup(void) { + chMtxInit(&m1); + chMtxInit(&m2); +} + +static msg_t thread13(void *p) { + + chThdSleepMilliseconds(50); + chMtxLock(&m2); + chMtxUnlock(); + return 0; +} + +static msg_t thread14(void *p) { + + chThdSleepMilliseconds(150); + chMtxLock(&m1); + chMtxUnlock(); + return 0; +} + +static void mtx4_execute(void) { + tprio_t p, p1, p2; + + p = chThdGetPriority(); + p1 = p + 1; + p2 = p + 2; + threads[0] = chThdCreateStatic(wa[0], WA_SIZE, p1, thread13, "B"); + threads[1] = chThdCreateStatic(wa[1], WA_SIZE, p2, thread14, "A"); + chMtxLock(&m2); + test_assert(chThdGetPriority() == p, "#1"); + chThdSleepMilliseconds(100); + test_assert(chThdGetPriority() == p1, "#2"); + chMtxLock(&m1); + test_assert(chThdGetPriority() == p1, "#3"); + chThdSleepMilliseconds(100); + test_assert(chThdGetPriority() == p2, "#4"); + chMtxUnlock(); + test_assert(chThdGetPriority() == p1, "#5"); + chThdSleepMilliseconds(100); + test_assert(chThdGetPriority() == p1, "#6"); + chMtxUnlockAll(); + test_assert(chThdGetPriority() == p, "#7"); + test_wait_threads(); +} + +const struct testcase testmtx4 = { + mtx4_gettest, + mtx4_setup, + NULL, + mtx4_execute +}; + +static char *mtx5_gettest(void) { + + return "Mutexes, coverage"; +} + +static void mtx5_setup(void) { + + chMtxInit(&m1); +} + +static void mtx5_execute(void) { + bool_t b; + tprio_t prio; + + prio = chThdGetPriority(); + + b = chMtxTryLock(&m1); + test_assert(b, "#1"); + + b = chMtxTryLock(&m1); + test_assert(!b, "#2"); + + chSysLock(); + chMtxUnlockS(); + chSysUnlock(); + + test_assert(isempty(&m1.m_queue), "#3"); /* Queue not empty */ + test_assert(m1.m_owner == NULL, "#4"); /* Owned */ + test_assert(chThdGetPriority() == prio, "#5"); +} + +const struct testcase testmtx5 = { + mtx5_gettest, + mtx5_setup, + NULL, + mtx5_execute +}; + +#if CH_USE_CONDVARS +static char *mtx6_gettest(void) { + + return "CondVar, signal test"; +} + +static void mtx6_setup(void) { + chCondInit(&c1); chMtxInit(&m1); } @@ -235,7 +332,7 @@ static msg_t thread10(void *p) { return 0; } -static void mtx4_execute(void) { +static void mtx6_execute(void) { tprio_t prio = chThdGetPriority(); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread10, "E"); @@ -252,25 +349,25 @@ static void mtx4_execute(void) { test_assert_sequence("ABCDE"); } -const struct testcase testmtx4 = { - mtx4_gettest, - mtx4_setup, +const struct testcase testmtx6 = { + mtx6_gettest, + mtx6_setup, NULL, - mtx4_execute + mtx6_execute }; -static char *mtx5_gettest(void) { +static char *mtx7_gettest(void) { return "CondVar, broadcast test"; } -static void mtx5_setup(void) { +static void mtx7_setup(void) { chCondInit(&c1); chMtxInit(&m1); } -static void mtx5_execute(void) { +static void mtx7_execute(void) { // Bacause priority inheritance. tprio_t prio = chThdGetPriority(); @@ -284,19 +381,19 @@ static void mtx5_execute(void) { test_assert_sequence("ABCDE"); } -const struct testcase testmtx5 = { - mtx5_gettest, - mtx5_setup, +const struct testcase testmtx7 = { + mtx7_gettest, + mtx7_setup, NULL, - mtx5_execute + mtx7_execute }; -static char *mtx6_gettest(void) { +static char *mtx8_gettest(void) { return "CondVar, inheritance boost test"; } -static void mtx6_setup(void) { +static void mtx8_setup(void) { chCondInit(&c1); chMtxInit(&m1); @@ -322,7 +419,7 @@ static msg_t thread12(void *p) { return 0; } -static void mtx6_execute(void) { +static void mtx8_execute(void) { tprio_t prio = chThdGetPriority(); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread11, "A"); @@ -334,11 +431,11 @@ static void mtx6_execute(void) { test_assert_sequence("ABC"); } -const struct testcase testmtx6 = { - mtx6_gettest, - mtx6_setup, +const struct testcase testmtx8 = { + mtx8_gettest, + mtx8_setup, NULL, - mtx6_execute + mtx8_execute }; #endif /* CH_USE_CONDVARS */ #endif /* CH_USE_MUTEXES */ @@ -351,10 +448,12 @@ const struct testcase * const patternmtx[] = { &testmtx1, &testmtx2, &testmtx3, -#if CH_USE_CONDVARS &testmtx4, &testmtx5, +#if CH_USE_CONDVARS &testmtx6, + &testmtx7, + &testmtx8, #endif #endif NULL -- cgit v1.2.3