andreika-git
/
ChibiOS
mirror of https://github.com/andreika-git/ChibiOS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@9130 35acf78f-673a-0410-8e92-d51de3d6d3f4

This commit is contained in:
Giovanni Di Sirio 2016-03-17 11:24:12 +00:00
parent 4b6e936c8a
commit fcae1afdb5
2 changed files with 592 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

321
test/nil/configuration.xml
View File

@ -563,19 +563,19 @@ test_assert((eventmask_t)0 == events, "wrong events mask");]]></value>
<value>This sequence tests the ChibiOS/NIL functionalities related to mailboxes.</value>
</description>
<shared_code>
<value><![CDATA[#define ALLOWED_DELAY MS2ST(5)
#define MB_SIZE 4
static msg_t mb_buffer[MB_SIZE];
<value><![CDATA[#define ALLOWED_DELAY MS2ST(5)
#define MB_SIZE 4
static msg_t mb_buffer[MB_SIZE];
static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);]]></value>
</shared_code>
<cases>
<case>
<brief>
<value>Mailbox non-blocking tests.</value>
<value>Mailbox normal API, non-blocking tests.</value>
</brief>
<description>
<value>The mailbox API is tested without triggering blocking conditions.</value>
<value>The mailbox normal API is tested without triggering blocking conditions.</value>
</description>
<condition>
<value>CH_CFG_USE_MAILBOXES</value>
@ -588,7 +588,8 @@ static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);]]></value>
<value><![CDATA[chMBReset(&mb1);]]></value>
</teardown_code>
<local_variables>
<value><![CDATA[msg_t msg1;]]></value>
<value><![CDATA[msg_t msg1, msg2;
unsigned i;]]></value>
</local_variables>
</various_code>
<steps>
@ -605,22 +606,312 @@ static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);]]></value>
</step>
<step>
<description>
<value>Testing forward and backward queuing, checking for no errors.</value>
<value>Resetting the mailbox, conditions are checked, no errors expected.</value>
</description>
<tags>
<value />
</tags>
<code>
<value><![CDATA[unsigned i;
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);
<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("ABCDE", "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) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not 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>
<value>CH_CFG_USE_MAILBOXES</value>
</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("ABCDE", "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) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not 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>
<value>CH_CFG_USE_MAILBOXES</value>
</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>

293
test/nil/source/test/test_sequence_004.c
View File

@ -29,6 +29,8 @@
*
* <h2>Test Cases</h2>
* - @subpage test_004_001
* - @subpage test_004_002
* - @subpage test_004_003
* .
*/
@ -48,10 +50,11 @@ static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);
#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
/**
* @page test_004_001 Mailbox non-blocking tests
* @page test_004_001 Mailbox normal API, non-blocking tests
*
* <h2>Description</h2>
* The mailbox API is tested without triggering blocking conditions.
* The mailbox normal API is tested without triggering blocking
* conditions.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
@ -61,7 +64,15 @@ static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);
*
* <h2>Test Steps</h2>
* - Testing the mailbox size.
* - Testing forward and backward queuing, checking for no errors.
* - Resetting the mailbox, conditions are checked, no errors expected.
* - Filling the mailbox using chMBPost() and chMBPostAhead() once, no
* errors expected.
* - Testing intermediate conditions. Data pointers must be aligned,
* semaphore counters are checked.
* - Emptying the mailbox using chMBFetch(), no errors expected.
* - Posting and then fetching one more message, no errors expected.
* - Testing final conditions. Data pointers must be aligned to buffer
* start, semaphore counters are checked.
* .
*/
@ -74,7 +85,8 @@ static void test_004_001_teardown(void) {
}
static void test_004_001_execute(void) {
msg_t msg1;
msg_t msg1, msg2;
unsigned i;
/* Testing the mailbox size.*/
test_set_step(1);
@ -82,11 +94,21 @@ static void test_004_001_execute(void) {
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");
}
/* Testing forward and backward queuing, checking for no errors.*/
/* Resetting the mailbox, conditions are checked, no errors
expected.*/
test_set_step(2);
{
unsigned i;
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");
}
/* Filling the mailbox using chMBPost() and chMBPostAhead() once, no
errors expected.*/
test_set_step(3);
{
for (i = 0; i < MB_SIZE - 1; i++) {
msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
@ -94,16 +116,267 @@ static void test_004_001_execute(void) {
msg1 = chMBPostAhead(&mb1, 'A', TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* Testing intermediate conditions. Data pointers must be aligned,
semaphore counters are checked.*/
test_set_step(4);
{
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");
}
/* Emptying the mailbox using chMBFetch(), no errors expected.*/
test_set_step(5);
{
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("ABCDE", "wrong get sequence");
}
/* Posting and then fetching one more message, no errors expected.*/
test_set_step(6);
{
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");
}
/* Testing final conditions. Data pointers must be aligned to buffer
start, semaphore counters are checked.*/
test_set_step(7);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not 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");
}
}
static const testcase_t test_004_001 = {
"Mailbox non-blocking tests",
"Mailbox normal API, non-blocking tests",
test_004_001_setup,
test_004_001_teardown,
test_004_001_execute
};
#endif /* CH_CFG_USE_MAILBOXES */
#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
/**
* @page test_004_002 Mailbox I-Class API, non-blocking tests
*
* <h2>Description</h2>
* The mailbox I-Class API is tested without triggering blocking
* conditions.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_MAILBOXES
* .
*
* <h2>Test Steps</h2>
* - Testing the mailbox size.
* - Resetting the mailbox, conditions are checked, no errors expected.
* - Filling the mailbox using chMBPostI() and chMBPostAheadI() once,
* no errors expected.
* - Testing intermediate conditions. Data pointers must be aligned,
* semaphore counters are checked.
* - Emptying the mailbox using chMBFetchI(), no errors expected.
* - Posting and then fetching one more message, no errors expected.
* - Testing final conditions. Data pointers must be aligned to buffer
* start, semaphore counters are checked.
* .
*/
static void test_004_002_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void test_004_002_teardown(void) {
chMBReset(&mb1);
}
static void test_004_002_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* Testing the mailbox size.*/
test_set_step(1);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");
}
/* Resetting the mailbox, conditions are checked, no errors
expected.*/
test_set_step(2);
{
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");
}
/* Filling the mailbox using chMBPostI() and chMBPostAheadI() once,
no errors expected.*/
test_set_step(3);
{
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");
}
/* Testing intermediate conditions. Data pointers must be aligned,
semaphore counters are checked.*/
test_set_step(4);
{
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");
}
/* Emptying the mailbox using chMBFetchI(), no errors expected.*/
test_set_step(5);
{
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("ABCDE", "wrong get sequence");
}
/* Posting and then fetching one more message, no errors expected.*/
test_set_step(6);
{
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");
}
/* Testing final conditions. Data pointers must be aligned to buffer
start, semaphore counters are checked.*/
test_set_step(7);
{
test_assert_lock(chMBGetFreeCountI(&mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not 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");
}
}
static const testcase_t test_004_002 = {
"Mailbox I-Class API, non-blocking tests",
test_004_002_setup,
test_004_002_teardown,
test_004_002_execute
};
#endif /* CH_CFG_USE_MAILBOXES */
#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
/**
* @page test_004_003 Mailbox timeouts
*
* <h2>Description</h2>
* The mailbox API is tested for timeouts.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_MAILBOXES
* .
*
* <h2>Test Steps</h2>
* - Filling the mailbox.
* - Testing chMBPost(), chMBPostI(), chMBPostAhead() and
* chMBPostAheadI() timeout.
* - Resetting the mailbox.
* - Testing chMBFetch() and chMBFetchI() timeout.
* .
*/
static void test_004_003_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void test_004_003_teardown(void) {
chMBReset(&mb1);
}
static void test_004_003_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* Filling the mailbox.*/
test_set_step(1);
{
for (i = 0; i < MB_SIZE; i++) {
msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
}
/* Testing chMBPost(), chMBPostI(), chMBPostAhead() and
chMBPostAheadI() timeout.*/
test_set_step(2);
{
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");
}
/* Resetting the mailbox.*/
test_set_step(3);
{
chMBReset(&mb1);
}
/* Testing chMBFetch() and chMBFetchI() timeout.*/
test_set_step(4);
{
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");
}
}
static const testcase_t test_004_003 = {
"Mailbox timeouts",
test_004_003_setup,
test_004_003_teardown,
test_004_003_execute
};
#endif /* CH_CFG_USE_MAILBOXES */
/****************************************************************************
* Exported data.
****************************************************************************/
@ -114,6 +387,12 @@ static const testcase_t test_004_001 = {
const testcase_t * const test_sequence_004[] = {
#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
&test_004_001,
#endif
#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
&test_004_002,
#endif
#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
&test_004_003,
#endif
NULL
};