2016-03-20 11:15:33 +00:00
<?xml version="1.0" encoding="UTF-8"?>
<SPC5-Config version= "1.0.0" >
<application name= "ChibiOS/RT Test Suite" version= "1.0.0" standalone= "true" locked= "false" >
<description > Test Specification for ChibiOS/RT.</description>
<component id= "org.chibios.spc5.components.platform.generic" >
<component id= "org.chibios.spc5.components.chibios_unitary_tests_engine" />
</component>
<instances >
<instance locked= "false" id= "org.chibios.spc5.components.platform.generic" />
<instance locked= "false" id= "org.chibios.spc5.components.chibios_unitary_tests_engine" >
<description >
<copyright >
<value > < ![CDATA[/*
ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/]]></value>
</copyright>
<introduction >
2016-03-20 11:37:22 +00:00
<value > Test suite for ChibiOS/RT. The purpose of this suite is to perform unit tests on the RT modules and to converge to 100% code coverage through successive improvements.</value>
2016-03-20 11:15:33 +00:00
</introduction>
</description>
<global_data_and_code >
<global_definitions >
2016-03-20 15:41:04 +00:00
<value > < ![CDATA[#define TEST_SUITE_NAME "ChibiOS/RT Test Suite"
2016-03-29 12:36:24 +00:00
/*
* Allowed delay in timeout checks.
*/
#define ALLOWED_DELAY MS2ST(2)
2016-03-20 15:41:04 +00:00
/*
* Maximum number of test threads.
*/
#define MAX_THREADS 5
/*
* Stack size of test threads.
*/
#if defined(CH_ARCHITECTURE_AVR) || defined(CH_ARCHITECTURE_MSP430)
#define THREADS_STACK_SIZE 48
#elif defined(CH_ARCHITECTURE_STM8)
#define THREADS_STACK_SIZE 64
#elif defined(CH_ARCHITECTURE_SIMIA32)
#define THREADS_STACK_SIZE 512
#else
#define THREADS_STACK_SIZE 128
#endif
/*
* Working Area size of test threads.
*/
#define WA_SIZE THD_WORKING_AREA_SIZE(THREADS_STACK_SIZE)
/*
* Union of all Working Areas, usable as a single large buffer if required.
*/
union test_buffers {
struct {
THD_WORKING_AREA(T0, THREADS_STACK_SIZE);
THD_WORKING_AREA(T1, THREADS_STACK_SIZE);
THD_WORKING_AREA(T2, THREADS_STACK_SIZE);
THD_WORKING_AREA(T3, THREADS_STACK_SIZE);
THD_WORKING_AREA(T4, THREADS_STACK_SIZE);
} wa;
uint8_t buffer[WA_SIZE * 5];
2016-03-22 08:53:10 +00:00
};
2016-03-29 10:34:51 +00:00
extern thread_t *threads[MAX_THREADS];
extern void * ROMCONST wa[5];
2016-03-22 08:53:10 +00:00
void test_terminate_threads(void);
2016-03-29 12:36:24 +00:00
void test_wait_threads(void);
systime_t test_wait_tick(void);]]></value>
2016-03-20 11:15:33 +00:00
</global_definitions>
<global_code >
2016-03-20 15:41:04 +00:00
<value > < ![CDATA[/*
* Static working areas, the following areas can be used for threads or
* used as temporary buffers.
*/
union test_buffers test;
/*
* Pointers to the spawned threads.
*/
thread_t *threads[MAX_THREADS];
/*
* Pointers to the working areas.
*/
void * ROMCONST wa[5] = {test.wa.T0, test.wa.T1, test.wa.T2,
2016-03-22 08:53:10 +00:00
test.wa.T3, test.wa.T4};
/*
* Sets a termination request in all the test-spawned threads.
*/
void test_terminate_threads(void) {
int i;
for (i = 0; i < MAX_THREADS ; i + + )
if (threads[i])
chThdTerminate(threads[i]);
}
/*
* Waits for the completion of all the test-spawned threads.
*/
void test_wait_threads(void) {
int i;
for (i = 0; i < MAX_THREADS ; i + + )
if (threads[i] != NULL) {
chThdWait(threads[i]);
threads[i] = NULL;
}
2016-03-29 12:36:24 +00:00
}
systime_t test_wait_tick(void) {
chThdSleep(1);
return chVTGetSystemTime();
2016-03-20 15:41:04 +00:00
}]]></value>
2016-03-20 11:15:33 +00:00
</global_code>
</global_data_and_code>
<sequences >
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
<value > System layer and port interface.</value>
</brief>
<description >
2016-03-20 11:37:22 +00:00
<value > The functionality of the system layer and port interface is tested. Basic RT functionality is taken for granted or this test suite could not even be executed. Errors in implementation are detected by executing this sequence with the state checker enabled (CH_DBG_STATE_CHECKER=TRUE).</value>
2016-03-20 11:15:33 +00:00
</description>
2016-03-22 08:53:10 +00:00
<condition >
<value />
</condition>
2016-03-20 11:15:33 +00:00
<shared_code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[/* Timer callback for testing system functions in ISR context.*/
2016-03-20 11:37:22 +00:00
static void vtcb(void *p) {
syssts_t sts;
(void)p;
/* Testing normal case.*/
chSysLockFromISR();
chSysUnlockFromISR();
/* Reentrant case.*/
chSysLockFromISR();
sts = chSysGetStatusAndLockX();
chSysRestoreStatusX(sts);
chSysUnlockFromISR();
2016-03-20 11:15:33 +00:00
}]]></value>
</shared_code>
<cases >
2016-03-20 11:37:22 +00:00
<case >
<brief >
<value > System integrity functionality.</value>
</brief>
<description >
<value > The system self-test functionality is invoked in order to make an initial system state assessment and for coverage.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > <![CDATA[bool result;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Testing Ready List integrity.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 15:41:04 +00:00
<value > < ![CDATA[chSysLock();
result = chSysIntegrityCheckI(CH_INTEGRITY_RLIST);
chSysUnlock();
2016-03-20 11:37:22 +00:00
test_assert(result == false, "ready list check failed");]]></value>
</code>
</step>
<step >
<description >
<value > Testing Virtual Timers List integrity.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 15:41:04 +00:00
<value > < ![CDATA[chSysLock();
result = chSysIntegrityCheckI(CH_INTEGRITY_VTLIST);
chSysUnlock();
2016-03-20 11:37:22 +00:00
test_assert(result == false, "virtual timers list check failed");]]></value>
</code>
</step>
<step >
<description >
<value > Testing Registry List integrity.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 15:41:04 +00:00
<value > < ![CDATA[chSysLock();
result = chSysIntegrityCheckI(CH_INTEGRITY_REGISTRY);
chSysUnlock();
2016-03-20 11:37:22 +00:00
test_assert(result == false, "registry list check failed");]]></value>
</code>
</step>
<step >
<description >
<value > Testing Port-defined integrity.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 15:41:04 +00:00
<value > < ![CDATA[chSysLock();
result = chSysIntegrityCheckI(CH_INTEGRITY_PORT);
chSysUnlock();
2016-03-20 11:37:22 +00:00
test_assert(result == false, "port layer check failed");]]></value>
</code>
</step>
</steps>
</case>
2016-03-20 11:15:33 +00:00
<case >
<brief >
<value > Critical zones functionality.</value>
</brief>
<description >
2016-03-20 11:37:22 +00:00
<value > The critical zones API is invoked for coverage.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
2016-03-20 11:37:22 +00:00
<value > < ![CDATA[syssts_t sts;
2016-03-20 11:15:33 +00:00
virtual_timer_t vt;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
2016-03-20 11:37:22 +00:00
<value > Testing chSysGetStatusAndLockX() and chSysRestoreStatusX(), non reentrant case.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 11:37:22 +00:00
<value > < ![CDATA[sts = chSysGetStatusAndLockX();
2016-03-20 11:15:33 +00:00
chSysRestoreStatusX(sts);]]></value>
</code>
</step>
<step >
<description >
2016-03-20 11:37:22 +00:00
<value > Testing chSysGetStatusAndLockX() and chSysRestoreStatusX(), reentrant case.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 11:37:22 +00:00
<value > < ![CDATA[chSysLock();
sts = chSysGetStatusAndLockX();
chSysRestoreStatusX(sts);
2016-03-20 11:15:33 +00:00
chSysUnlock();]]></value>
</code>
</step>
<step >
<description >
<value > Testing chSysUnconditionalLock().</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 11:37:22 +00:00
<value > < ![CDATA[chSysUnconditionalLock();
chSysUnconditionalLock();
2016-03-20 11:15:33 +00:00
chSysUnlock();]]></value>
</code>
</step>
<step >
<description >
<value > Testing chSysUnconditionalUnlock().</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 11:37:22 +00:00
<value > < ![CDATA[chSysLock();
chSysUnconditionalUnlock();
2016-03-20 11:15:33 +00:00
chSysUnconditionalUnlock();]]></value>
</code>
</step>
<step >
<description >
<value > Testing from ISR context using a virtual timer.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-20 11:37:22 +00:00
<value > < ![CDATA[chVTObjectInit(&vt);
chVTSet(& vt, 1, vtcb, NULL);
chThdSleep(10);
2016-03-20 11:15:33 +00:00
test_assert(chVTIsArmed(& vt) == false, "timer still armed");]]></value>
</code>
</step>
</steps>
</case>
2016-03-20 11:37:22 +00:00
<case >
<brief >
<value > Interrupts handling functionality.</value>
</brief>
<description >
<value > The interrupts handling API is invoked for coverage.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Testing chSysSuspend(), chSysDisable() and chSysEnable().</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chSysSuspend();
chSysDisable();
chSysSuspend();
chSysEnable();]]></value>
</code>
</step>
</steps>
</case>
2016-03-20 11:15:33 +00:00
<case >
<brief >
<value > System Tick Counter functionality.</value>
</brief>
<description >
<value > The functionality of the API @p chVTGetSystemTimeX() is tested.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > A System Tick Counter increment is expected, the test simply hangs if it does not happen.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[systime_t time = chVTGetSystemTimeX();
while (time == chVTGetSystemTimeX()) {
}]]></value>
</code>
</step>
</steps>
</case>
2016-03-20 15:41:04 +00:00
</cases>
</sequence>
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
<value > Threads Functionality.</value>
</brief>
<description >
2016-03-29 12:36:24 +00:00
<value > This sequence tests the ChibiOS/RT functionalities related to threading.</value>
2016-03-20 15:41:04 +00:00
</description>
2016-03-22 08:53:10 +00:00
<condition >
<value />
</condition>
2016-03-20 15:41:04 +00:00
<shared_code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[static THD_FUNCTION(thread, p) {
2016-03-22 08:53:10 +00:00
test_emit_token(*(char *)p);
2016-03-20 15:41:04 +00:00
}]]></value>
</shared_code>
<cases >
2016-03-20 11:15:33 +00:00
<case >
<brief >
<value > Thread Sleep functionality.</value>
</brief>
<description >
<value > The functionality of @p chThdSleep() and derivatives is tested.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > <![CDATA[systime_t time;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > The current system time is read then a sleep is performed for 100 system ticks and on exit the system time is verified again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[time = chVTGetSystemTimeX();
chThdSleep(100);
test_assert_time_window(time + 100,
2016-03-20 15:41:04 +00:00
time + 100 + CH_CFG_ST_TIMEDELTA + 1,
2016-03-20 11:15:33 +00:00
"out of time window");]]></value>
</code>
</step>
<step >
<description >
<value > The current system time is read then a sleep is performed for 100000 microseconds and on exit the system time is verified again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[time = chVTGetSystemTimeX();
chThdSleepMicroseconds(100000);
test_assert_time_window(time + US2ST(100000),
2016-03-20 15:41:04 +00:00
time + US2ST(100000) + CH_CFG_ST_TIMEDELTA + 1,
2016-03-20 11:15:33 +00:00
"out of time window");]]></value>
</code>
</step>
<step >
<description >
<value > The current system time is read then a sleep is performed for 100 milliseconds and on exit the system time is verified again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[time = chVTGetSystemTimeX();
chThdSleepMilliseconds(100);
test_assert_time_window(time + MS2ST(100),
2016-03-20 15:41:04 +00:00
time + MS2ST(100) + CH_CFG_ST_TIMEDELTA + 1,
2016-03-20 11:15:33 +00:00
"out of time window");]]></value>
</code>
</step>
<step >
<description >
<value > The current system time is read then a sleep is performed for 1 second and on exit the system time is verified again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[time = chVTGetSystemTimeX();
chThdSleepSeconds(1);
test_assert_time_window(time + S2ST(1),
2016-03-20 15:41:04 +00:00
time + S2ST(1) + CH_CFG_ST_TIMEDELTA + 1,
2016-03-20 11:15:33 +00:00
"out of time window");]]></value>
</code>
</step>
<step >
<description >
<value > Function chThdSleepUntil() is tested with a timeline of "now" + 100 ticks.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[time = chVTGetSystemTimeX();
chThdSleepUntil(time + 100);
test_assert_time_window(time + 100,
2016-03-20 15:41:04 +00:00
time + 100 + CH_CFG_ST_TIMEDELTA + 1,
2016-03-20 11:15:33 +00:00
"out of time window");]]></value>
</code>
</step>
</steps>
</case>
2016-03-20 15:41:04 +00:00
<case >
<brief >
<value > Ready List functionality, threads priority order.</value>
</brief>
<description >
<value > Five threads, are enqueued in the ready list and atomically executed. The test expects the threads to perform their operations in correct priority order regardless of the initial order.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Creating 5 threads with increasing priority, execution sequence is tested.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-22 08:53:10 +00:00
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
test_wait_threads();
2016-03-29 10:34:51 +00:00
test_assert_sequence("ABCDE", "invalid sequence");]]></value>
2016-03-20 15:41:04 +00:00
</code>
</step>
<step >
<description >
<value > Creating 5 threads with decreasing priority, execution sequence is tested.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-22 08:53:10 +00:00
<value > < ![CDATA[threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
test_wait_threads();
2016-03-29 10:34:51 +00:00
test_assert_sequence("ABCDE", "invalid sequence");]]></value>
2016-03-20 15:41:04 +00:00
</code>
</step>
<step >
<description >
<value > Creating 5 threads with pseudo-random priority, execution sequence is tested.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-22 08:53:10 +00:00
<value > < ![CDATA[threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
test_wait_threads();
2016-03-29 10:34:51 +00:00
test_assert_sequence("ABCDE", "invalid sequence");]]></value>
2016-03-20 15:41:04 +00:00
</code>
</step>
</steps>
</case>
2016-03-20 11:15:33 +00:00
<case >
<brief >
2016-03-28 14:22:13 +00:00
<value > Priority change test.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-28 14:22:13 +00:00
<value > A series of priority changes are performed on the current thread in order to verify that the priority change happens as expected.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
2016-03-28 14:22:13 +00:00
<value />
2016-03-20 11:15:33 +00:00
</setup_code>
<teardown_code >
2016-03-28 14:22:13 +00:00
<value />
2016-03-20 11:15:33 +00:00
</teardown_code>
<local_variables >
2016-03-28 14:22:13 +00:00
<value > <![CDATA[tprio_t prio, p1;]]> </value>
2016-03-20 11:15:33 +00:00
</local_variables>
</various_code>
<steps >
<step >
<description >
2016-03-28 14:22:13 +00:00
<value > Thread priority is increased by one then a check is performed.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[prio = chThdGetPriorityX();
p1 = chThdSetPriority(prio + 1);
test_assert(p1 == prio, "unexpected returned priority level");
2016-03-28 14:22:13 +00:00
test_assert(chThdGetPriorityX() == prio + 1, "unexpected priority level");]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
<step >
<description >
2016-03-28 14:22:13 +00:00
<value > Thread priority is returned to the previous value then a check is performed.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[p1 = chThdSetPriority(p1);
test_assert(p1 == prio + 1, "unexpected returned priority level");
2016-03-28 14:22:13 +00:00
test_assert(chThdGetPriorityX() == prio, "unexpected priority level");]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
</steps>
</case>
<case >
<brief >
2016-03-28 14:22:13 +00:00
<value > Priority change test with Priority Inheritance.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-28 14:22:13 +00:00
<value > A series of priority changes are performed on the current thread in order to verify that the priority change happens as expected.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
2016-03-28 14:22:13 +00:00
<value > CH_CFG_USE_MUTEXES</value>
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
2016-03-28 14:22:13 +00:00
<value />
2016-03-20 11:15:33 +00:00
</setup_code>
<teardown_code >
2016-03-28 14:22:13 +00:00
<value />
2016-03-20 11:15:33 +00:00
</teardown_code>
<local_variables >
2016-03-28 14:22:13 +00:00
<value > <![CDATA[tprio_t prio, p1;]]> </value>
2016-03-20 11:15:33 +00:00
</local_variables>
</various_code>
<steps >
<step >
<description >
2016-03-28 14:22:13 +00:00
<value > Simulating a priority boost situation (prio > realprio).</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 12:36:24 +00:00
<value > < ![CDATA[prio = chThdGetPriorityX();
2016-03-29 10:34:51 +00:00
chThdGetSelfX()->prio += 2;
2016-03-28 14:22:13 +00:00
test_assert(chThdGetPriorityX() == prio + 2, "unexpected priority level");]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
<step >
<description >
2016-03-28 14:22:13 +00:00
<value > Raising thread priority above original priority but below the boosted level.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[p1 = chThdSetPriority(prio + 1);
test_assert(p1 == prio, "unexpected returned priority level");
test_assert(chThdGetSelfX()->prio == prio + 2, "unexpected priority level");
2016-03-28 14:22:13 +00:00
test_assert(chThdGetSelfX()->realprio == prio + 1, "unexpected returned real priority level");]]></value>
</code>
</step>
<step >
<description >
<value > Raising thread priority above the boosted level.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[p1 = chThdSetPriority(prio + 3);
test_assert(p1 == prio + 1, "unexpected returned priority level");
test_assert(chThdGetSelfX()->prio == prio + 3, "unexpected priority level");
2016-03-28 14:22:13 +00:00
test_assert(chThdGetSelfX()->realprio == prio + 3, "unexpected real priority level");]]></value>
</code>
</step>
<step >
<description >
<value > Restoring original conditions.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[chSysLock();
chThdGetSelfX()->prio = prio;
chThdGetSelfX()->realprio = prio;
2016-03-28 14:22:13 +00:00
chSysUnlock();]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
</steps>
</case>
2016-03-28 14:22:13 +00:00
</cases>
</sequence>
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
2016-03-29 10:34:51 +00:00
<value > Suspend/Resume.</value>
2016-03-28 14:22:13 +00:00
</brief>
<description >
2016-03-29 10:34:51 +00:00
<value > This sequence tests the ChibiOS/RT functionalities related to threads suspend/resume.</value>
2016-03-28 14:22:13 +00:00
</description>
<condition >
2016-03-29 10:34:51 +00:00
<value />
2016-03-28 14:22:13 +00:00
</condition>
<shared_code >
2016-03-29 12:36:24 +00:00
<value > < ![CDATA[static thread_reference_t tr1;
static THD_FUNCTION(thread1, p) {
chThdResumeI(& tr1, MSG_OK);
test_emit_token(*(char *)p);
2016-03-29 10:34:51 +00:00
}]]></value>
2016-03-28 14:22:13 +00:00
</shared_code>
<cases >
2016-03-20 11:15:33 +00:00
<case >
<brief >
2016-03-29 10:34:51 +00:00
<value > Suspend and Resume functionality.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-29 10:34:51 +00:00
<value > The functionality of chThdSuspendTimeoutS() and chThdResumeI() is tested.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
2016-03-29 10:34:51 +00:00
<value > <![CDATA[tr1 = NULL;]]> </value>
2016-03-20 11:15:33 +00:00
</setup_code>
<teardown_code >
2016-03-29 10:34:51 +00:00
<value />
2016-03-20 11:15:33 +00:00
</teardown_code>
<local_variables >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[systime_t time;
msg_t msg;]]></value>
2016-03-20 11:15:33 +00:00
</local_variables>
</various_code>
<steps >
<step >
<description >
2016-03-29 10:34:51 +00:00
<value > The function chThdSuspendTimeoutS() is invoked, the thread is remotely resumed with message @p MSG_OK. On return the message and the state of the reference are tested.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 12:36:24 +00:00
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-1, thread1, "A");
2016-03-29 10:34:51 +00:00
chSysLock();
msg = chThdSuspendTimeoutS(& tr1, TIME_INFINITE);
chSysUnlock();
test_assert(NULL == tr1, "not NULL");
2016-03-29 12:36:24 +00:00
test_assert(MSG_OK == msg,"wrong returned message");
2016-03-29 10:34:51 +00:00
test_wait_threads();]]></value>
2016-03-28 14:22:13 +00:00
</code>
</step>
<step >
<description >
2016-03-29 10:34:51 +00:00
<value > The function chThdSuspendTimeoutS() is invoked, the thread is not resumed so a timeout must occur. On return the message and the state of the reference are tested.</value>
2016-03-28 14:22:13 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[chSysLock();
time = chVTGetSystemTimeX();
msg = chThdSuspendTimeoutS(& tr1, MS2ST(1000));
chSysUnlock();
test_assert_time_window(time + MS2ST(1000),
time + MS2ST(1000) + 1,
"out of time window");
test_assert(NULL == tr1, "not NULL");
test_assert(MSG_TIMEOUT == msg, "wrong returned message");]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
</steps>
</case>
</cases>
</sequence>
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
2016-03-29 12:36:24 +00:00
<value > Counter and Binary Semaphores.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-29 12:36:24 +00:00
<value > This sequence tests the ChibiOS/RT functionalities related to counter semaphores.</value>
2016-03-20 11:15:33 +00:00
</description>
2016-03-22 08:53:10 +00:00
<condition >
2016-03-29 10:34:51 +00:00
<value > CH_CFG_USE_SEMAPHORES</value>
2016-03-22 08:53:10 +00:00
</condition>
2016-03-20 11:15:33 +00:00
<shared_code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[#include "ch.h"
static semaphore_t sem1;
static THD_FUNCTION(thread1, p) {
chSemWait(&sem1);
test_emit_token(*(char *)p);
2016-03-29 12:36:24 +00:00
}
static THD_FUNCTION(thread2, p) {
(void)p;
chThdSleepMilliseconds(50);
chSysLock();
chSemSignalI(&sem1); /* For coverage reasons */
chSchRescheduleS();
chSysUnlock();
}
static THD_FUNCTION(thread3, p) {
(void)p;
chSemWait(&sem1);
chSemSignal(&sem1);
}
static THD_FUNCTION(thread4, p) {
chBSemSignal((binary_semaphore_t *)p);
2016-03-29 10:34:51 +00:00
}]]></value>
2016-03-20 11:15:33 +00:00
</shared_code>
<cases >
<case >
<brief >
2016-03-29 10:34:51 +00:00
<value > Semaphore primitives, no state change.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-29 10:34:51 +00:00
<value > Wait, Signal and Reset primitives are tested. The testing thread does not trigger a state change.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
2016-03-29 10:34:51 +00:00
<value > <![CDATA[chSemObjectInit(&sem1, 1);]]> </value>
2016-03-20 11:15:33 +00:00
</setup_code>
<teardown_code >
2016-03-29 10:34:51 +00:00
<value > <![CDATA[chSemReset(&sem1, 0);]]> </value>
2016-03-20 11:15:33 +00:00
</teardown_code>
<local_variables >
2016-03-29 10:34:51 +00:00
<value />
2016-03-20 11:15:33 +00:00
</local_variables>
</various_code>
<steps >
<step >
<description >
2016-03-29 10:34:51 +00:00
<value > The function chSemWait() is invoked, after return the counter and the returned message are tested.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[msg_t msg;
msg = chSemWait(&sem1);
test_assert_lock(chSemGetCounterI(& sem1) == 0, "wrong counter value");
test_assert(MSG_OK == msg, "wrong returned message");]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
<step >
<description >
2016-03-29 10:34:51 +00:00
<value > The function chSemSignal() is invoked, after return the counter is tested.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[chSemSignal(&sem1);
test_assert_lock(chSemGetCounterI(& sem1) == 1, "wrong counter value");]]></value>
</code>
</step>
<step >
<description >
<value > The function chSemReset() is invoked, after return the counter is tested.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chSemReset(& sem1, 2);
test_assert_lock(chSemGetCounterI(& sem1) == 2, "wrong counter value");]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
</steps>
</case>
<case >
<brief >
2016-03-29 10:34:51 +00:00
<value > Semaphore enqueuing test.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-29 10:34:51 +00:00
<value > Five threads with randomized priorities are enqueued to a semaphore then awakened one at time. The test expects that the threads reach their goal in FIFO order or priority order depending on the @p CH_CFG_USE_SEMAPHORES_PRIORITY configuration setting.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
2016-03-29 10:34:51 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
2016-03-29 10:34:51 +00:00
<value > <![CDATA[chSemObjectInit(&sem1, 0);]]> </value>
2016-03-20 11:15:33 +00:00
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
2016-03-29 10:34:51 +00:00
<value />
2016-03-20 11:15:33 +00:00
</local_variables>
</various_code>
<steps >
<step >
<description >
2016-03-29 10:34:51 +00:00
<value > Five threads are created with mixed priority levels (not increasing nor decreasing). Threads enqueue on a semaphore initialized to zero.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+5, thread1, "A");
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()+1, thread1, "B");
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()+3, thread1, "C");
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()+4, thread1, "D");
threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()+2, thread1, "E");]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
<step >
<description >
2016-03-29 10:34:51 +00:00
<value > The semaphore is signaled 5 times. The thread activation sequence is tested.</value>
2016-03-20 11:15:33 +00:00
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 10:34:51 +00:00
<value > < ![CDATA[chSemSignal(&sem1);
chSemSignal(&sem1);
chSemSignal(&sem1);
chSemSignal(&sem1);
chSemSignal(&sem1);
test_wait_threads();
#if CH_CFG_USE_SEMAPHORES_PRIORITY
test_assert_sequence("ADCEB", "invalid sequence");
#else
test_assert_sequence("ABCDE", "invalid sequence");
#endif]]></value>
2016-03-20 11:15:33 +00:00
</code>
</step>
</steps>
</case>
2016-03-29 12:36:24 +00:00
<case >
<brief >
<value > Semaphore timeout test.</value>
</brief>
<description >
<value > The three possible semaphore waiting modes (do not wait, wait with timeout, wait without timeout) are explored. The test expects that the semaphore wait function returns the correct value in each of the above scenario and that the semaphore structure status is correct after each operation.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chSemObjectInit(&sem1, 0);]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > < ![CDATA[unsigned i;
systime_t target_time;
msg_t msg;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Testing special case TIME_IMMEDIATE.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[msg = chSemWaitTimeout(& sem1, TIME_IMMEDIATE);
test_assert(msg == MSG_TIMEOUT, "wrong wake-up message");
test_assert(queue_isempty(& sem1.queue), "queue not empty");
test_assert(sem1.cnt == 0, "counter not zero");]]></value>
</code>
</step>
<step >
<description >
<value > Testing non-timeout condition.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
thread2, 0);
msg = chSemWaitTimeout(& sem1, MS2ST(500));
test_wait_threads();
test_assert(msg == MSG_OK, "wrong wake-up message");
test_assert(queue_isempty(& sem1.queue), "queue not empty");
test_assert(sem1.cnt == 0, "counter not zero");]]></value>
</code>
</step>
<step >
<description >
<value > Testing timeout condition.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[target_time = test_wait_tick() + MS2ST(5 * 50);
for (i = 0; i < 5 ; i + + ) {
test_emit_token('A' + i);
msg = chSemWaitTimeout(& sem1, MS2ST(50));
test_assert(msg == MSG_TIMEOUT, "wrong wake-up message");
test_assert(queue_isempty(& sem1.queue), "queue not empty");
test_assert(sem1.cnt == 0, "counter not zero");
}
test_assert_sequence("ABCDE", "invalid sequence");
test_assert_time_window(target_time, target_time + ALLOWED_DELAY,
"out of time window");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Testing chSemAddCounterI() functionality.</value>
</brief>
<description >
<value > The functon is tested by waking up a thread then the semaphore counter value is tested.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chSemObjectInit(&sem1, 0);]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > A thread is created, it goes to wait on the semaphore.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+1, thread1, "A");]]> </value>
</code>
</step>
<step >
<description >
<value > The semaphore counter is increased by two, it is then tested to be one, the thread must have completed.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chSysLock();
chSemAddCounterI(& sem1, 2);
chSchRescheduleS();
chSysUnlock();
test_wait_threads();
test_assert_lock(chSemGetCounterI(& sem1) == 1, "invalid counter");
test_assert_sequence("A", "invalid sequence");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Testing chSemWaitSignal() functionality.</value>
</brief>
<description >
<value > This test case explicitly addresses the @p chSemWaitSignal() function. A thread is created that performs a wait and a signal operations. The tester thread is awakened from an atomic wait/signal operation. The test expects that the semaphore wait function returns the correct value in each of the above scenario and that the semaphore structure status is correct after each operation.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chSemObjectInit(&sem1, 0);]]> </value>
</setup_code>
<teardown_code >
2016-03-30 15:58:48 +00:00
<value > <![CDATA[test_wait_threads();]]> </value>
2016-03-29 12:36:24 +00:00
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > An higher priority thread is created that performs non-atomical wait and signal operations on a semaphore.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+1, thread3, 0);]]> </value>
</code>
</step>
<step >
<description >
<value > The function chSemSignalWait() is invoked by specifying the same semaphore for the wait and signal phases. The counter value must be one on exit.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chSemSignalWait(& sem1, &sem1);
test_assert(queue_isempty(& sem1.queue), "queue not empty");
test_assert(sem1.cnt == 0, "counter not zero");]]></value>
</code>
</step>
<step >
<description >
<value > The function chSemSignalWait() is invoked again by specifying the same semaphore for the wait and signal phases. The counter value must be one on exit.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chSemSignalWait(& sem1, &sem1);
test_assert(queue_isempty(& sem1.queue), "queue not empty");
test_assert(sem1.cnt == 0, "counter not zero");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Testing Binary Semaphores special case.</value>
</brief>
<description >
<value > This test case tests the binary semaphores functionality. The test both checks the binary semaphore status and the expected status of the underlying counting semaphore.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
2016-03-29 15:33:45 +00:00
<value > < ![CDATA[binary_semaphore_t bsem;
2016-03-29 12:36:24 +00:00
msg_t msg;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Creating a binary semaphore in "taken" state, the state is checked.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 15:33:45 +00:00
<value > < ![CDATA[chBSemObjectInit(& bsem, true);
2016-03-29 12:36:24 +00:00
test_assert_lock(chBSemGetStateI(& bsem) == true, "not taken");]]></value>
</code>
</step>
<step >
<description >
<value > Resetting the binary semaphore in "taken" state, the state must not change.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chBSemReset(& bsem, true);
test_assert_lock(chBSemGetStateI(& bsem) == true, "not taken");]]></value>
</code>
</step>
<step >
<description >
<value > Starting a signaler thread at a lower priority.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 15:33:45 +00:00
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE,
2016-03-29 12:36:24 +00:00
chThdGetPriorityX()-1, thread4, &bsem); ]]></value>
</code>
</step>
<step >
<description >
<value > Waiting for the binary semaphore to be signaled, the semaphore is expected to be taken.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 15:33:45 +00:00
<value > < ![CDATA[msg = chBSemWait(&bsem);
test_assert_lock(chBSemGetStateI(& bsem) == true, "not taken");
2016-03-29 12:36:24 +00:00
test_assert(msg == MSG_OK, "unexpected message");]]></value>
</code>
</step>
<step >
<description >
<value > Signaling the binary semaphore, checking the binary semaphore state to be "not taken" and the underlying counter semaphore counter to be one.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 15:33:45 +00:00
<value > < ![CDATA[chBSemSignal(&bsem);
test_assert_lock(chBSemGetStateI(& bsem) ==false, "still taken");
2016-03-29 12:36:24 +00:00
test_assert_lock(chSemGetCounterI(& bsem.sem) == 1, "unexpected counter");]]></value>
</code>
</step>
<step >
<description >
<value > Signaling the binary semaphore again, the internal state must not change from "not taken".</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-29 15:33:45 +00:00
<value > < ![CDATA[chBSemSignal(&bsem);
test_assert_lock(chBSemGetStateI(& bsem) == false, "taken");
2016-03-29 12:36:24 +00:00
test_assert_lock(chSemGetCounterI(& bsem.sem) == 1, "unexpected counter");]]></value>
</code>
</step>
</steps>
</case>
2016-03-20 11:15:33 +00:00
</cases>
</sequence>
2016-03-29 12:36:24 +00:00
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
<value > Mutexes, Condition Variables and Priority Inheritance.</value>
</brief>
<description >
<value > This sequence tests the ChibiOS/RT functionalities related to mutexes, condition variables and priority inheritance algorithm.</value>
</description>
<condition >
<value > CH_CFG_USE_MUTEXES</value>
</condition>
<shared_code >
2016-03-29 15:33:45 +00:00
<value > < ![CDATA[static MUTEX_DECL(m1);
static MUTEX_DECL(m2);
#if CH_CFG_USE_CONDVARS || defined(__DOXYGEN__)
static CONDVAR_DECL(c1);
#endif
#if CH_DBG_THREADS_PROFILING || defined(__DOXYGEN__)
/**
* @brief CPU pulse.
* @note The current implementation is not totally reliable.
*
* @param[in] duration CPU pulse duration in milliseconds
*/
void test_cpu_pulse(unsigned duration) {
systime_t start, end, now;
start = chThdGetTicksX(chThdGetSelfX());
end = start + MS2ST(duration);
do {
now = chThdGetTicksX(chThdGetSelfX());
#if defined(SIMULATOR)
_sim_check_for_interrupts();
#endif
}
while (chVTIsTimeWithinX(now, start, end));
}
#endif /* CH_DBG_THREADS_PROFILING */
static THD_FUNCTION(thread1, p) {
chMtxLock(&m1);
test_emit_token(*(char *)p);
chMtxUnlock(&m1);
}
/* Low priority thread */
static THD_FUNCTION(thread2L, p) {
(void)p;
chMtxLock(&m1);
test_cpu_pulse(40);
chMtxUnlock(&m1);
test_cpu_pulse(10);
test_emit_token('C');
}
/* Medium priority thread */
static THD_FUNCTION(thread2M, p) {
(void)p;
chThdSleepMilliseconds(20);
test_cpu_pulse(40);
test_emit_token('B');
}
/* High priority thread */
static THD_FUNCTION(thread2H, p) {
(void)p;
chThdSleepMilliseconds(40);
chMtxLock(&m1);
test_cpu_pulse(10);
chMtxUnlock(&m1);
test_emit_token('A');
}
/* Lowest priority thread */
static THD_FUNCTION(thread3LL, p) {
(void)p;
chMtxLock(&m1);
test_cpu_pulse(30);
chMtxUnlock(&m1);
test_emit_token('E');
}
/* Low priority thread */
static THD_FUNCTION(thread3L, p) {
(void)p;
chThdSleepMilliseconds(10);
chMtxLock(&m2);
test_cpu_pulse(20);
chMtxLock(&m1);
test_cpu_pulse(10);
chMtxUnlock(&m1);
test_cpu_pulse(10);
chMtxUnlock(&m2);
test_emit_token('D');
}
/* Medium priority thread */
static THD_FUNCTION(thread3M, p) {
(void)p;
chThdSleepMilliseconds(20);
chMtxLock(&m2);
test_cpu_pulse(10);
chMtxUnlock(&m2);
test_emit_token('C');
}
/* High priority thread */
static THD_FUNCTION(thread3H, p) {
(void)p;
chThdSleepMilliseconds(40);
test_cpu_pulse(20);
test_emit_token('B');
}
/* Highest priority thread */
static THD_FUNCTION(thread3HH, p) {
(void)p;
chThdSleepMilliseconds(50);
chMtxLock(&m2);
test_cpu_pulse(10);
chMtxUnlock(&m2);
test_emit_token('A');
}
static THD_FUNCTION(thread4A, p) {
(void)p;
chThdSleepMilliseconds(50);
chMtxLock(&m1);
chMtxUnlock(&m1);
}
static THD_FUNCTION(thread4B, p) {
(void)p;
chThdSleepMilliseconds(150);
chSysLock();
chMtxLockS(&m2); /* For coverage of the chMtxLockS() function variant.*/
chMtxUnlockS(&m2); /* For coverage of the chMtxUnlockS() function variant.*/
chSchRescheduleS();
chSysUnlock();
}
#if CH_CFG_USE_CONDVARS || defined(__DOXYGEN__)
static THD_FUNCTION(thread6, p) {
chMtxLock(&m1);
chCondWait(&c1);
test_emit_token(*(char *)p);
chMtxUnlock(&m1);
}
static THD_FUNCTION(thread8, p) {
chMtxLock(&m2);
chMtxLock(&m1);
#if CH_CFG_USE_CONDVARS_TIMEOUT || defined(__DOXYGEN__)
chCondWaitTimeout(& c1, TIME_INFINITE);
#else
chCondWait(&c1);
#endif
test_emit_token(*(char *)p);
chMtxUnlock(&m1);
chMtxUnlock(&m2);
}
#endif /* CH_CFG_USE_CONDVARS */]]></value>
2016-03-29 12:36:24 +00:00
</shared_code>
2016-03-29 15:33:45 +00:00
<cases >
<case >
<brief >
<value > Priority enqueuing test.</value>
</brief>
<description >
<value > Five threads, with increasing priority, are enqueued on a locked mutex then the mutex is unlocked. The test expects the threads to perform their operations in increasing priority order regardless of the initial order.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chMtxObjectInit(&m1);]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > <![CDATA[tprio_t prio;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Getting the initial priority.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[prio = chThdGetPriorityX();]]> </value>
</code>
</step>
<step >
<description >
<value > Locking the mutex.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[chMtxLock(&m1);]]> </value>
</code>
</step>
<step >
<description >
<value > Five threads are created that try to lock and unlock the mutex then terminate. The threads are created in ascending priority order.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread1, "E");
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread1, "D");
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread1, "C");
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread1, "B");
threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread1, "A");]]></value>
</code>
</step>
<step >
<description >
<value > Unlocking the mutex, the threads will wakeup in priority order because the mutext queue is an ordered one.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxUnlock(&m1);
test_wait_threads();
test_assert(prio == chThdGetPriorityX(), "wrong priority level");
test_assert_sequence("ABCDE", "invalid sequence");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Priority inheritance, simple case.</value>
</brief>
<description >
<value > Three threads are involved in the classic priority inversion scenario, a medium priority thread tries to starve an high priority thread by blocking a low priority thread into a mutex lock zone. The test expects the threads to reach their goal in increasing priority order by rearranging their priorities in order to avoid the priority inversion trap.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chMtxObjectInit(&m1);]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > <![CDATA[systime_t time;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Getting the system time for test duration measurement.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[time = test_wait_tick();]]> </value>
</code>
</step>
<step >
<description >
<value > The three contenders threads are created and let run atomically, the goals sequence is tested, the threads must complete in priority order.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-1, thread2H, 0);
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-2, thread2M, 0);
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread2L, 0);
test_wait_threads();
test_assert_sequence("ABC", "invalid sequence");]]></value>
</code>
</step>
<step >
<description >
<value > Testing that all threads completed within the specified time windows (100mS...100mS+ALLOWED_DELAY).</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[test_assert_time_window(time + MS2ST(100), time + MS2ST(100) + ALLOWED_DELAY,
"out of time window");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Priority inheritance, complex case.</value>
</brief>
<description >
<value > Five threads are involved in the complex priority inversion scenario, the priority inheritance algorithm is tested for depths greater than one. The test expects the threads to perform their operations in increasing priority order by rearranging their priorities in order to avoid the priority inversion trap.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value > < ![CDATA[chMtxObjectInit(&m1); /* Mutex B.*/
chMtxObjectInit(&m2); /* Mutex A.*/]]></value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > <![CDATA[systime_t time;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Getting the system time for test duration measurement.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[time = test_wait_tick();]]> </value>
</code>
</step>
<step >
<description >
<value > The five contenders threads are created and let run atomically, the goals sequence is tested, the threads must complete in priority order.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread3LL, 0);
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread3L, 0);
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread3M, 0);
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread3H, 0);
threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread3HH, 0);
test_wait_threads();
test_assert_sequence("ABCDE", "invalid sequence");]]></value>
</code>
</step>
<step >
<description >
<value > Testing that all threads completed within the specified time windows (110mS...110mS+ALLOWED_DELAY).</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[test_assert_time_window(time + MS2ST(110), time + MS2ST(110) + ALLOWED_DELAY,
"out of time window");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Priority return verification.</value>
</brief>
<description >
<value > Two threads are spawned that try to lock the mutexes already locked by the tester thread with precise timing. The test expects that the priority changes caused by the priority inheritance algorithm happen at the right moment and with the right values.< br> 
Thread A performs wait(50), lock(m1), unlock(m1), exit. Thread B performs wait(150), lock(m2), unlock(m2), exit.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value > < ![CDATA[chMtxObjectInit(&m1);
chMtxObjectInit(&m2); ]]></value>
</setup_code>
<teardown_code >
2016-03-30 15:58:48 +00:00
<value > <![CDATA[test_wait_threads();]]> </value>
2016-03-29 15:33:45 +00:00
</teardown_code>
<local_variables >
<value > <![CDATA[tprio_t p, pa, pb;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Getting current thread priority P(0) and assigning to the threads A and B priorities +1 and +2.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p = chThdGetPriorityX();
pa = p + 1;
pb = p + 2;]]></value>
</code>
</step>
<step >
<description >
<value > Spawning threads A and B at priorities P(A) and P(B).</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, pa, thread4A, "A");
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, pb, thread4B, "B");]]></value>
</code>
</step>
<step >
<description >
<value > Locking the mutex M1 before thread A has a chance to lock it. The priority must not change because A has not yet reached chMtxLock(M1). the mutex is not locked.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxLock(&m1);
test_assert(chThdGetPriorityX() == p, "wrong priority level");]]></value>
</code>
</step>
<step >
<description >
<value > Waiting 100mS, this makes thread A reach chMtxLock(M1) and get the mutex. This must boost the priority of the current thread at the same level of thread A.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chThdSleepMilliseconds(100);
test_assert(chThdGetPriorityX() == pa, "wrong priority level");]]></value>
</code>
</step>
<step >
<description >
<value > Locking the mutex M2 before thread B has a chance to lock it. The priority must not change because B has not yet reached chMtxLock(M2). the mutex is not locked.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxLock(&m2);
test_assert(chThdGetPriorityX() == pa, "wrong priority level");]]></value>
</code>
</step>
<step >
<description >
<value > Waiting 100mS, this makes thread B reach chMtxLock(M2) and get the mutex. This must boost the priority of the current thread at the same level of thread B.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chThdSleepMilliseconds(100);
test_assert(chThdGetPriorityX() == pb, "wrong priority level");]]></value>
</code>
</step>
<step >
<description >
<value > Unlocking M2, the priority should fall back to P(A).</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxUnlock(&m2);
test_assert(chThdGetPriorityX() == pa, "wrong priority level");]]></value>
</code>
</step>
<step >
<description >
<value > Unlocking M1, the priority should fall back to P(0).</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxUnlock(&m1);
test_assert(chThdGetPriorityX() == p, "wrong priority level");]]></value>
</code>
</step>
</steps>
</case>
2016-03-30 14:33:58 +00:00
<case >
<brief >
<value > Repeated locks, non recursive scenario.</value>
</brief>
<description >
<value > The behavior of multiple mutex locks from the same thread is tested when recursion is disabled</value>
</description>
<condition >
<value > !CH_CFG_USE_MUTEXES_RECURSIVE</value>
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chMtxObjectInit(&m1);]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > < ![CDATA[bool b;
tprio_t prio;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Getting current thread priority for later checks.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[prio = chThdGetPriorityX();]]> </value>
</code>
</step>
<step >
<description >
<value > Locking the mutex first time, it must be possible because it is not owned.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[b = chMtxTryLock(&m1);
test_assert(b, "already locked");]]></value>
</code>
</step>
<step >
<description >
<value > Locking the mutex second time, it must fail because it is already owned.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[b = chMtxTryLock(&m1);
test_assert(!b, "not locked");]]></value>
</code>
</step>
<step >
<description >
<value > Unlocking the mutex then it must not be owned anymore and the queue must be empty.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxUnlock(&m1);
test_assert(m1.owner == NULL, "still owned");
test_assert(queue_isempty(& m1.queue), "queue not empty");]]></value>
</code>
</step>
<step >
<description >
<value > Testing that priority has not changed after operations.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chThdGetPriorityX() == prio, "wrong priority level");]]> </value>
</code>
</step>
<step >
<description >
<value > Testing chMtxUnlockAll() behavior.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-30 15:18:47 +00:00
<value > < ![CDATA[b = chMtxTryLock(&m1);
test_assert(b, "already locked");
b = chMtxTryLock(&m1);
test_assert(!b, "not locked");
chMtxUnlockAll();
test_assert(m1.owner == NULL, "still owned");
2016-03-30 14:33:58 +00:00
test_assert(queue_isempty(& m1.queue), "queue not empty");]]></value>
</code>
</step>
<step >
<description >
<value > Testing that priority has not changed after operations.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chThdGetPriorityX() == prio, "wrong priority level");]]> </value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Repeated locks using, recursive scenario.</value>
</brief>
<description >
<value > The behavior of multiple mutex locks from the same thread is tested when recursion is enabled</value>
</description>
<condition >
<value > CH_CFG_USE_MUTEXES_RECURSIVE</value>
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chMtxObjectInit(&m1);]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > < ![CDATA[bool b;
tprio_t prio;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Getting current thread priority for later checks.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[prio = chThdGetPriorityX();]]> </value>
</code>
</step>
<step >
<description >
<value > Locking the mutex first time, it must be possible because it is not owned.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[b = chMtxTryLock(&m1);
test_assert(b, "already locked");]]></value>
</code>
</step>
<step >
<description >
<value > Locking the mutex second time, it must be possible because it is recursive.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[b = chMtxTryLock(&m1);
test_assert(b, "already locked");]]></value>
</code>
</step>
<step >
<description >
<value > Unlocking the mutex then it must be still owned because recursivity.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxUnlock(&m1);
test_assert(m1.owner != NULL, "not owned");]]></value>
</code>
</step>
<step >
<description >
<value > Unlocking the mutex then it must not be owned anymore and the queue must be empty.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMtxUnlock(&m1);
test_assert(m1.owner == NULL, "still owned");
test_assert(queue_isempty(& m1.queue), "queue not empty");]]></value>
</code>
</step>
<step >
<description >
<value > Testing that priority has not changed after operations.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chThdGetPriorityX() == prio, "wrong priority level");]]> </value>
</code>
</step>
<step >
<description >
<value > Testing consecutive chMtxTryLock()/chMtxTryLockS() calls and a final chMtxUnlockAllS().</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-30 15:18:47 +00:00
<value > < ![CDATA[b = chMtxTryLock(&m1);
test_assert(b, "already locked");
chSysLock();
b = chMtxTryLockS(&m1);
chSysUnlock();
test_assert(b, "already locked");
test_assert(m1.cnt == 2, "invalid recursion counter");
chSysLock();
chMtxUnlockAllS();
chSysUnlock();
test_assert(m1.owner == NULL, "still owned");
test_assert(queue_isempty(& m1.queue), "queue not empty");
2016-03-30 14:33:58 +00:00
test_assert(m1.cnt == 0, "invalid recursion counter");]]></value>
</code>
</step>
<step >
<description >
<value > Testing consecutive chMtxLock()/chMtxLockS() calls and a final chMtxUnlockAll().</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-30 15:18:47 +00:00
<value > < ![CDATA[chMtxLock(&m1);
test_assert(m1.owner != NULL, "not owned");
chSysLock();
chMtxLockS(&m1);
chSysUnlock();
test_assert(m1.owner != NULL, "not owned");
test_assert(m1.cnt == 2, "invalid recursion counter");
chMtxUnlockAll();
test_assert(m1.owner == NULL, "still owned");
test_assert(queue_isempty(& m1.queue), "queue not empty");
2016-03-30 14:33:58 +00:00
test_assert(m1.cnt == 0, "invalid recursion counter");]]></value>
</code>
</step>
<step >
<description >
<value > Testing that priority has not changed after operations.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chThdGetPriorityX() == prio, "wrong priority level");]]> </value>
</code>
</step>
</steps>
</case>
2016-03-30 15:18:47 +00:00
<case >
<brief >
<value > Condition Variable signal test.</value>
</brief>
<description >
<value > Five threads take a mutex and then enter a conditional variable queue, the tester thread then proceeds to signal the conditional variable five times atomically.< br> 
The test expects the threads to reach their goal in increasing priority order regardless of the initial order.</value>
</description>
<condition >
<value > CH_CFG_USE_CONDVARS</value>
</condition>
<various_code >
<setup_code >
2016-03-30 15:58:48 +00:00
<value > < ![CDATA[chCondObjectInit(&c1);
2016-03-30 15:18:47 +00:00
chMtxObjectInit(&m1); ]]></value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Starting the five threads with increasing priority, the threads will queue on the condition variable.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-30 15:58:48 +00:00
<value > < ![CDATA[tprio_t prio = chThdGetPriorityX();
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread6, "E");
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread6, "D");
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread6, "C");
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread6, "B");
2016-03-30 15:18:47 +00:00
threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread6, "A");]]></value>
</code>
</step>
<step >
<description >
<value > Atomically signaling the condition variable five times then waiting for the threads to terminate in priority order, the order is tested.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-30 15:58:48 +00:00
<value > < ![CDATA[chSysLock();
chCondSignalI(&c1);
chCondSignalI(&c1);
chCondSignalI(&c1);
chCondSignalI(&c1);
chCondSignalI(&c1);
chSchRescheduleS();
chSysUnlock();
test_wait_threads();
2016-03-30 15:18:47 +00:00
test_assert_sequence("ABCDE", "invalid sequence");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Condition Variable broadcast test.</value>
</brief>
<description >
<value > Five threads take a mutex and then enter a conditional variable queue, the tester thread then proceeds to broadcast the conditional variable.< br> 
The test expects the threads to reach their goal in increasing priority order regardless of the initial order.</value>
</description>
<condition >
<value > CH_CFG_USE_CONDVARS</value>
</condition>
<various_code >
<setup_code >
2016-03-30 15:58:48 +00:00
<value > < ![CDATA[chCondObjectInit(&c1);
chMtxObjectInit(&m1);
chMtxObjectInit(&m2); ]]></value>
2016-03-30 15:18:47 +00:00
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Starting the five threads with increasing priority, the threads will queue on the condition variable.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-30 15:58:48 +00:00
<value > < ![CDATA[tprio_t prio = chThdGetPriorityX();
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread8, "E");
threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread8, "D");
threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread8, "C");
threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread8, "B");
2016-03-30 15:18:47 +00:00
threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread8, "A");]]></value>
</code>
</step>
<step >
<description >
<value > Broarcasting on the condition variable then waiting for the threads to terminate in priority order, the order is tested.</value>
</description>
<tags >
<value />
</tags>
<code >
2016-03-30 15:58:48 +00:00
<value > < ![CDATA[chCondBroadcast(&c1);
test_wait_threads();
2016-03-30 15:18:47 +00:00
test_assert_sequence("ABCDE", "invalid sequence");]]></value>
</code>
</step>
</steps>
</case>
2016-03-29 15:33:45 +00:00
</cases>
2016-03-29 12:36:24 +00:00
</sequence>
2016-03-30 15:58:48 +00:00
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
<value > Synchronous Messages.</value>
</brief>
<description >
<value > This module implements the test sequence for the Synchronous Messages subsystem.</value>
</description>
<condition >
<value > CH_CFG_USE_MESSAGES</value>
</condition>
<shared_code >
<value > < ![CDATA[static THD_FUNCTION(msg_thread1, p) {
chMsgSend(p, 'A');
chMsgSend(p, 'B');
chMsgSend(p, 'C');
chMsgSend(p, 'D');
}]]></value>
</shared_code>
<cases >
<case >
<brief >
<value > Messages Server loop.</value>
</brief>
<description >
<value > A messenger thread is spawned that sends four messages back to the tester thread.< br> 
The test expect to receive the messages in the correct sequence and to not find a fifth message waiting.</value>
</description>
<condition >
<value />
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > < ![CDATA[thread_t *tp;
msg_t msg;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Starting the messenger thread.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() + 1,
msg_thread1, chThdGetSelfX());]]></value>
</code>
</step>
<step >
<description >
<value > Waiting for four messages then testing the receive order.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[unsigned i;
for (i = 0; i < 4 ; i + + ) {
tp = chMsgWait();
msg = chMsgGet(tp);
chMsgRelease(tp, msg);
test_emit_token(msg);
}
test_wait_threads();
test_assert_sequence("ABCD", "invalid sequence");]]></value>
</code>
</step>
</steps>
</case>
</cases>
</sequence>
2016-03-20 11:15:33 +00:00
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
<value > Mailboxes.</value>
</brief>
<description >
2016-03-29 12:36:24 +00:00
<value > This sequence tests the ChibiOS/RT functionalities related to mailboxes.</value>
2016-03-20 11:15:33 +00:00
</description>
2016-03-22 08:53:10 +00:00
<condition >
<value > CH_CFG_USE_MAILBOXES</value>
</condition>
2016-03-20 11:15:33 +00:00
<shared_code >
2016-03-29 12:36:24 +00:00
<value > < ![CDATA[#define MB_SIZE 4
2016-03-20 11:15:33 +00:00
static msg_t mb_buffer[MB_SIZE];
static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);]]></value>
</shared_code>
<cases >
<case >
<brief >
<value > Mailbox normal API, non-blocking tests.</value>
</brief>
<description >
<value > The mailbox normal API is tested without triggering blocking conditions.</value>
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chMBObjectInit(&mb1, mb_buffer, MB_SIZE);]]> </value>
</setup_code>
<teardown_code >
<value > <![CDATA[chMBReset(&mb1);]]> </value>
</teardown_code>
<local_variables >
<value > < ![CDATA[msg_t msg1, msg2;
unsigned i;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Testing the mailbox size.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");]]> </value>
</code>
</step>
<step >
<description >
<value > Resetting the mailbox, conditions are checked, no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chMBReset(&mb1);
test_assert_lock(chMBGetFreeCountI(& mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(& mb1) == 0, "still full");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");]]></value>
</code>
</step>
<step >
<description >
<value > Filling the mailbox using chMBPost() and chMBPostAhead() once, no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MB_SIZE - 1 ; i + + ) {
msg1 = chMBPost(& mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
msg1 = chMBPostAhead(& mb1, 'A', TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>
</code>
</step>
<step >
<description >
<value > Testing intermediate conditions. Data pointers must be aligned, semaphore counters are checked.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[test_assert_lock(chMBGetFreeCountI(& mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(& mb1) == MB_SIZE, "not full");
test_assert_lock(mb1.rdptr == mb1.wrptr, "pointers not aligned");]]></value>
</code>
</step>
<step >
<description >
<value > Emptying the mailbox using chMBFetch(), no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MB_SIZE ; i + + ) {
msg1 = chMBFetch(& mb1, & msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
test_emit_token(msg2);
}
test_assert_sequence("ABCD", "wrong get sequence");]]></value>
</code>
</step>
<step >
<description >
<value > Posting and then fetching one more message, no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[msg1 = chMBPost(& mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetch(& mb1, & msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>
</code>
</step>
<step >
<description >
<value > Testing final conditions. Data pointers must be aligned to buffer start, semaphore counters are checked.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[test_assert_lock(chMBGetFreeCountI(& mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(& mb1) == 0, "still full");
test_assert(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Mailbox I-Class API, non-blocking tests.</value>
</brief>
<description >
<value > The mailbox I-Class API is tested without triggering blocking conditions.</value>
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chMBObjectInit(&mb1, mb_buffer, MB_SIZE);]]> </value>
</setup_code>
<teardown_code >
<value > <![CDATA[chMBReset(&mb1);]]> </value>
</teardown_code>
<local_variables >
<value > < ![CDATA[msg_t msg1, msg2;
unsigned i;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Testing the mailbox size.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");]]> </value>
</code>
</step>
<step >
<description >
<value > Resetting the mailbox, conditions are checked, no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chSysLock();
chMBResetI(&mb1);
chSysUnlock();
test_assert_lock(chMBGetFreeCountI(& mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(& mb1) == 0, "still full");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");]]></value>
</code>
</step>
<step >
<description >
<value > Filling the mailbox using chMBPostI() and chMBPostAheadI() once, no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MB_SIZE - 1 ; i + + ) {
chSysLock();
msg1 = chMBPostI(& mb1, 'B' + i);
chSysUnlock();
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
chSysLock();
msg1 = chMBPostAheadI(& mb1, 'A');
chSysUnlock();
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>
</code>
</step>
<step >
<description >
<value > Testing intermediate conditions. Data pointers must be aligned, semaphore counters are checked.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[test_assert_lock(chMBGetFreeCountI(& mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(& mb1) == MB_SIZE, "not full");
test_assert_lock(mb1.rdptr == mb1.wrptr, "pointers not aligned");]]></value>
</code>
</step>
<step >
<description >
<value > Emptying the mailbox using chMBFetchI(), no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MB_SIZE ; i + + ) {
chSysLock();
msg1 = chMBFetchI(& mb1, &msg2);
chSysUnlock();
test_assert(msg1 == MSG_OK, "wrong wake-up message");
test_emit_token(msg2);
}
test_assert_sequence("ABCD", "wrong get sequence");]]></value>
</code>
</step>
<step >
<description >
<value > Posting and then fetching one more message, no errors expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[msg1 = chMBPost(& mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetch(& mb1, & msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>
</code>
</step>
<step >
<description >
<value > Testing final conditions. Data pointers must be aligned to buffer start, semaphore counters are checked.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[test_assert_lock(chMBGetFreeCountI(& mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(& mb1) == 0, "still full");
test_assert(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Mailbox timeouts.</value>
</brief>
<description >
<value > The mailbox API is tested for timeouts.</value>
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chMBObjectInit(&mb1, mb_buffer, MB_SIZE);]]> </value>
</setup_code>
<teardown_code >
<value > <![CDATA[chMBReset(&mb1);]]> </value>
</teardown_code>
<local_variables >
<value > < ![CDATA[msg_t msg1, msg2;
unsigned i;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Filling the mailbox.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MB_SIZE ; i + + ) {
msg1 = chMBPost(& mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}]]></value>
</code>
</step>
<step >
<description >
<value > Testing chMBPost(), chMBPostI(), chMBPostAhead() and chMBPostAheadI() timeout.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[msg1 = chMBPost(& mb1, 'X', 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBPostI(& mb1, 'X');
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
msg1 = chMBPostAhead(& mb1, 'X', 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBPostAheadI(& mb1, 'X');
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");]]></value>
</code>
</step>
<step >
<description >
<value > Resetting the mailbox.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[chMBReset(&mb1);]]> </value>
</code>
</step>
<step >
<description >
<value > Testing chMBFetch() and chMBFetchI() timeout.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[msg1 = chMBFetch(& mb1, & msg2, 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBFetchI(& mb1, &msg2);
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");]]></value>
</code>
</step>
</steps>
</case>
</cases>
</sequence>
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
<value > Memory Pools.</value>
</brief>
<description >
2016-03-29 12:36:24 +00:00
<value > This sequence tests the ChibiOS/RT functionalities related to memory pools.</value>
2016-03-20 11:15:33 +00:00
</description>
2016-03-22 08:53:10 +00:00
<condition >
<value > CH_CFG_USE_MEMPOOLS</value>
</condition>
2016-03-20 11:15:33 +00:00
<shared_code >
<value > < ![CDATA[#define MEMORY_POOL_SIZE 4
static uint32_t objects[MEMORY_POOL_SIZE];
static MEMORYPOOL_DECL(mp1, sizeof (uint32_t), NULL);
static GUARDEDMEMORYPOOL_DECL(gmp1, sizeof (uint32_t));
static void *null_provider(size_t size, unsigned align) {
(void)size;
(void)align;
return NULL;
}]]></value>
</shared_code>
<cases >
<case >
<brief >
2016-03-22 10:55:31 +00:00
<value > Loading and emptying a memory pool.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-22 10:55:31 +00:00
<value > The memory pool functionality is tested by loading and emptying it, all conditions are tested.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chPoolObjectInit(&mp1, sizeof (uint32_t), NULL);]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > <![CDATA[unsigned i;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Adding the objects to the pool using chPoolLoadArray().</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[chPoolLoadArray(&mp1, objects, MEMORY_POOL_SIZE);]]> </value>
</code>
</step>
<step >
<description >
<value > Emptying the pool using chPoolAlloc().</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MEMORY_POOL_SIZE ; i + + )
test_assert(chPoolAlloc(& mp1) != NULL, "list empty");]]></value>
</code>
</step>
<step >
<description >
<value > Now must be empty.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chPoolAlloc(&mp1) == NULL, "list not empty");]]> </value>
</code>
</step>
<step >
<description >
<value > Adding the objects to the pool using chPoolFree().</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MEMORY_POOL_SIZE ; i + + )
chPoolFree(& mp1, &objects[i]); ]]></value>
</code>
</step>
<step >
<description >
<value > Emptying the pool using chPoolAlloc() again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MEMORY_POOL_SIZE ; i + + )
test_assert(chPoolAlloc(& mp1) != NULL, "list empty");]]></value>
</code>
</step>
<step >
<description >
<value > Now must be empty again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chPoolAlloc(&mp1) == NULL, "list not empty");]]> </value>
</code>
</step>
<step >
<description >
<value > Covering the case where a provider is unable to return more memory.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[chPoolObjectInit(& mp1, sizeof (uint32_t), null_provider);
test_assert(chPoolAlloc(& mp1) == NULL, "provider returned memory");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
2016-03-22 10:55:31 +00:00
<value > Loading and emptying a guarded memory pool without waiting.</value>
2016-03-20 11:15:33 +00:00
</brief>
<description >
2016-03-22 10:55:31 +00:00
<value > The memory pool functionality is tested by loading and emptying it, all conditions are tested.</value>
2016-03-20 11:15:33 +00:00
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value > CH_CFG_USE_SEMAPHORES</value>
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t));]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > <![CDATA[unsigned i;]]> </value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Adding the objects to the pool using chGuardedPoolLoadArray().</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[chGuardedPoolLoadArray(&gmp1, objects, MEMORY_POOL_SIZE);]]> </value>
</code>
</step>
<step >
<description >
<value > Emptying the pool using chGuardedPoolAllocTimeout().</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MEMORY_POOL_SIZE ; i + + )
test_assert(chGuardedPoolAllocTimeout(& gmp1, TIME_IMMEDIATE) != NULL, "list empty");]]></value>
</code>
</step>
<step >
<description >
<value > Now must be empty.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty");]]> </value>
</code>
</step>
<step >
<description >
<value > Adding the objects to the pool using chGuardedPoolFree().</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MEMORY_POOL_SIZE ; i + + )
chGuardedPoolFree(& gmp1, &objects[i]); ]]></value>
</code>
</step>
<step >
<description >
<value > Emptying the pool using chGuardedPoolAllocTimeout() again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[for (i = 0; i < MEMORY_POOL_SIZE ; i + + )
test_assert(chGuardedPoolAllocTimeout(& gmp1, TIME_IMMEDIATE) != NULL, "list empty");]]></value>
</code>
</step>
<step >
<description >
<value > Now must be empty again.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty");]]> </value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Guarded Memory Pools timeout.</value>
</brief>
<description >
<value > The timeout features for the Guarded Memory Pools is tested.</value>
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value > CH_CFG_USE_SEMAPHORES</value>
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t));]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value />
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Trying to allocate with 100mS timeout, must fail because the pool is empty.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chGuardedPoolAllocTimeout(&gmp1, MS2ST(100)) == NULL, "list not empty");]]> </value>
</code>
</step>
</steps>
</case>
</cases>
</sequence>
<sequence >
<type index= "0" >
<value > Internal Tests</value>
</type>
<brief >
<value > Memory Heaps.</value>
</brief>
<description >
2016-03-29 12:36:24 +00:00
<value > This sequence tests the ChibiOS/RT functionalities related to memory heaps.</value>
2016-03-20 11:15:33 +00:00
</description>
2016-03-22 08:53:10 +00:00
<condition >
<value > CH_CFG_USE_HEAP</value>
</condition>
2016-03-20 11:15:33 +00:00
<shared_code >
<value > < ![CDATA[#define ALLOC_SIZE 16
#define HEAP_SIZE (ALLOC_SIZE * 8)
static memory_heap_t test_heap;
static CH_HEAP_AREA(myheap, HEAP_SIZE);]]></value>
</shared_code>
<cases >
<case >
<brief >
<value > Allocation and fragmentation.</value>
</brief>
<description >
<value > Series of allocations/deallocations are performed in carefully designed sequences in order to stimulate all the possible code paths inside the allocator. The test expects to find the heap back to the initial status after each sequence.</value>
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value > <![CDATA[chHeapObjectInit(&test_heap, myheap, sizeof(myheap));]]> </value>
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > < ![CDATA[void *p1, *p2, *p3;
size_t n, sz;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Testing initial conditions, the heap must not be fragmented and one free block present.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > <![CDATA[test_assert(chHeapStatus(&test_heap, &sz, NULL) == 1, "heap fragmented");]]> </value>
</code>
</step>
<step >
<description >
<value > Trying to allocate an block bigger than available space, an error is expected.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p1 = chHeapAlloc(& test_heap, HEAP_SIZE * 2);
test_assert(p1 == NULL, "allocation not failed");]]></value>
</code>
</step>
<step >
<description >
<value > Single block allocation using chHeapAlloc() then the block is freed using chHeapFree(), must not fail.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p1 = chHeapAlloc(& test_heap, ALLOC_SIZE);
test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);]]></value>
</code>
</step>
<step >
<description >
<value > Using chHeapStatus() to assess the heap state. There must be at least one free block of sufficient size.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[size_t total_size, largest_size;
n = chHeapStatus(& test_heap, & total_size, &largest_size);
test_assert(n == 1, "missing free block");
test_assert(total_size >= ALLOC_SIZE, "unexpected heap state");
test_assert(total_size == largest_size, "unexpected heap state");]]></value>
</code>
</step>
<step >
<description >
<value > Allocating then freeing in the same order.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p1 = chHeapAlloc(& test_heap, ALLOC_SIZE);
p2 = chHeapAlloc(& test_heap, ALLOC_SIZE);
p3 = chHeapAlloc(& test_heap, ALLOC_SIZE);
chHeapFree(p1); /* Does not merge.*/
chHeapFree(p2); /* Merges backward.*/
chHeapFree(p3); /* Merges both sides.*/
test_assert(chHeapStatus(& test_heap, & n, NULL) == 1, "heap fragmented");]]></value>
</code>
</step>
<step >
<description >
<value > Allocating then freeing in reverse order.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p1 = chHeapAlloc(& test_heap, ALLOC_SIZE);
p2 = chHeapAlloc(& test_heap, ALLOC_SIZE);
p3 = chHeapAlloc(& test_heap, ALLOC_SIZE);
chHeapFree(p3); /* Merges forward.*/
chHeapFree(p2); /* Merges forward.*/
chHeapFree(p1); /* Merges forward.*/
test_assert(chHeapStatus(& test_heap, & n, NULL) == 1, "heap fragmented");]]></value>
</code>
</step>
<step >
<description >
<value > Small fragments handling. Checking the behavior when allocating blocks with size not multiple of alignment unit.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p1 = chHeapAlloc(& test_heap, ALLOC_SIZE + 1);
p2 = chHeapAlloc(& test_heap, ALLOC_SIZE);
chHeapFree(p1);
test_assert(chHeapStatus(& test_heap, & n, NULL) == 2, "invalid state");
p1 = chHeapAlloc(& test_heap, ALLOC_SIZE);
/* Note, the first situation happens when the alignment size is smaller
than the header size, the second in the other cases.*/
test_assert((chHeapStatus(& test_heap, & n, NULL) == 1) ||
(chHeapStatus(& test_heap, & n, NULL) == 2), "heap fragmented");
chHeapFree(p2);
chHeapFree(p1);
test_assert(chHeapStatus(& test_heap, & n, NULL) == 1, "heap fragmented");]]></value>
</code>
</step>
<step >
<description >
<value > Skipping a fragment, the first fragment in the list is too small so the allocator must pick the second one.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p1 = chHeapAlloc(& test_heap, ALLOC_SIZE);
p2 = chHeapAlloc(& test_heap, ALLOC_SIZE);
chHeapFree(p1);
test_assert( chHeapStatus(& test_heap, & n, NULL) == 2, "invalid state");
p1 = chHeapAlloc(& test_heap, ALLOC_SIZE * 2); /* Skips first fragment.*/
chHeapFree(p1);
chHeapFree(p2);
test_assert(chHeapStatus(& test_heap, & n, NULL) == 1, "heap fragmented");]]></value>
</code>
</step>
<step >
<description >
<value > Allocating the whole available space.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[(void)chHeapStatus(& test_heap, & n, NULL);
p1 = chHeapAlloc(& test_heap, n);
test_assert(p1 != NULL, "allocation failed");
test_assert(chHeapStatus(& test_heap, NULL, NULL) == 0, "not empty");
chHeapFree(p1);]]></value>
</code>
</step>
<step >
<description >
<value > Testing final conditions. The heap geometry must be the same than the one registered at beginning.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[test_assert(chHeapStatus(& test_heap, & n, NULL) == 1, "heap fragmented");
test_assert(n == sz, "size changed");]]></value>
</code>
</step>
</steps>
</case>
<case >
<brief >
<value > Default Heap.</value>
</brief>
<description >
<value > The default heap is pre-allocated in the system. We test base functionality.</value>
</description>
<condition >
2016-03-22 08:53:10 +00:00
<value />
2016-03-20 11:15:33 +00:00
</condition>
<various_code >
<setup_code >
<value />
</setup_code>
<teardown_code >
<value />
</teardown_code>
<local_variables >
<value > < ![CDATA[void *p1;
size_t total_size, largest_size;]]></value>
</local_variables>
</various_code>
<steps >
<step >
<description >
<value > Single block allocation using chHeapAlloc() then the block is freed using chHeapFree(), must not fail.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[(void)chHeapStatus(NULL, & total_size, &largest_size);
p1 = chHeapAlloc(& test_heap, ALLOC_SIZE);
test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);]]></value>
</code>
</step>
<step >
<description >
<value > Testing allocation failure.</value>
</description>
<tags >
<value />
</tags>
<code >
<value > < ![CDATA[p1 = chHeapAlloc(NULL, (size_t)-256);
test_assert(p1 == NULL, "allocation not failed");]]></value>
</code>
</step>
</steps>
</case>
</cases>
</sequence>
</sequences>
</instance>
</instances>
<exportedFeatures />
</application>
</SPC5-Config>
