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

Various test improvements. 

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@12647 110e8d01-0319-4d1e-a829-52ad28d1bb01
This commit is contained in:
Giovanni Di Sirio 2019-02-09 08:11:14 +00:00
parent 16623868ba
commit 541d51a68d
16 changed files with 1932 additions and 1612 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
readme.txt
View File

@ -79,10 +79,10 @@
using _sbrk_r() does not contain "holes" caused by other allocators. using _sbrk_r() does not contain "holes" caused by other allocators.
- LIB: Modified core allocator to be able to get blocks starting from bottom - LIB: Modified core allocator to be able to get blocks starting from bottom
or top of the available memory range. or top of the available memory range.
Removed alignment enforcements for requested block size. Alignment is Removed alignment enforcement for requested block size. Alignment is
only ensured on the returned pointer, this should reduce memory usage only ensured on the returned pointer, this should reduce memory usage
is some cases. is some cases.
- HAL: Added a new interface for rangefinder devices (used by EX). - HAL: Added a new interface for range-finder devices (used by EX).
- HAL: Added mcuconf.h updater tool for STM32F407 (backported to 19.1.1). - HAL: Added mcuconf.h updater tool for STM32F407 (backported to 19.1.1).
- NIL: Integrated NIL 4.0. - NIL: Integrated NIL 4.0.
- FIX: Fixed uninitialized variables in STM32 DMA drivers (bug #1010) - FIX: Fixed uninitialized variables in STM32 DMA drivers (bug #1010)

43
test/nil/configuration.xml
View File

@ -272,47 +272,8 @@ test_println("");
test_print("--- CH_CFG_USE_EVENTS: "); test_print("--- CH_CFG_USE_EVENTS: ");
test_printn(CH_CFG_USE_EVENTS); test_printn(CH_CFG_USE_EVENTS);
test_println(""); test_println("");
test_print("--- CH_CFG_USE_MAILBOXES: "); test_print("--- CH_CFG_USE_MESSAGES: ");
test_printn(CH_CFG_USE_MAILBOXES); test_printn(CH_CFG_USE_MESSAGES);
test_println("");
test_print("--- CH_CFG_USE_MEMCORE: ");
test_printn(CH_CFG_USE_MEMCORE);
test_println("");
test_print("--- CH_CFG_USE_HEAP: ");
test_printn(CH_CFG_USE_HEAP);
test_println("");
test_print("--- CH_CFG_USE_MEMPOOLS: ");
test_printn(CH_CFG_USE_MEMPOOLS);
test_println("");
test_print("--- CH_CFG_USE_OBJ_FIFOS: ");
test_printn(CH_CFG_USE_OBJ_FIFOS);
test_println("");
test_print("--- CH_CFG_MEMCORE_SIZE: ");
test_printn(CH_CFG_MEMCORE_SIZE);
test_println("");
test_print("--- CH_CFG_USE_FACTORY: ");
test_printn(CH_CFG_USE_FACTORY);
test_println("");
test_print("--- CH_CFG_FACTORY_MAX_NAMES_LENGTH: ");
test_printn(CH_CFG_FACTORY_MAX_NAMES_LENGTH);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJECTS_REGISTRY: ");
test_printn(CH_CFG_FACTORY_OBJECTS_REGISTRY);
test_println("");
test_print("--- CH_CFG_FACTORY_GENERIC_BUFFERS: ");
test_printn(CH_CFG_FACTORY_GENERIC_BUFFERS);
test_println("");
test_print("--- CH_CFG_FACTORY_SEMAPHORES: ");
test_printn(CH_CFG_FACTORY_SEMAPHORES);
test_println("");
test_print("--- CH_CFG_FACTORY_MAILBOXES: ");
test_printn(CH_CFG_FACTORY_MAILBOXES);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJ_FIFOS: ");
test_printn(CH_CFG_FACTORY_OBJ_FIFOS);
test_println("");
test_print("--- CH_CFG_USE_PIPES: ");
test_printn(CH_CFG_USE_PIPES);
test_println(""); test_println("");
test_print("--- CH_DBG_STATISTICS: "); test_print("--- CH_DBG_STATISTICS: ");
test_printn(CH_DBG_STATISTICS); test_printn(CH_DBG_STATISTICS);

43
test/nil/source/test/nil_test_sequence_001.c
View File

@ -187,47 +187,8 @@ static void nil_test_001_003_execute(void) {
test_print("--- CH_CFG_USE_EVENTS: "); test_print("--- CH_CFG_USE_EVENTS: ");
test_printn(CH_CFG_USE_EVENTS); test_printn(CH_CFG_USE_EVENTS);
test_println(""); test_println("");
test_print("--- CH_CFG_USE_MAILBOXES: "); test_print("--- CH_CFG_USE_MESSAGES: ");
test_printn(CH_CFG_USE_MAILBOXES); test_printn(CH_CFG_USE_MESSAGES);
test_println("");
test_print("--- CH_CFG_USE_MEMCORE: ");
test_printn(CH_CFG_USE_MEMCORE);
test_println("");
test_print("--- CH_CFG_USE_HEAP: ");
test_printn(CH_CFG_USE_HEAP);
test_println("");
test_print("--- CH_CFG_USE_MEMPOOLS: ");
test_printn(CH_CFG_USE_MEMPOOLS);
test_println("");
test_print("--- CH_CFG_USE_OBJ_FIFOS: ");
test_printn(CH_CFG_USE_OBJ_FIFOS);
test_println("");
test_print("--- CH_CFG_MEMCORE_SIZE: ");
test_printn(CH_CFG_MEMCORE_SIZE);
test_println("");
test_print("--- CH_CFG_USE_FACTORY: ");
test_printn(CH_CFG_USE_FACTORY);
test_println("");
test_print("--- CH_CFG_FACTORY_MAX_NAMES_LENGTH: ");
test_printn(CH_CFG_FACTORY_MAX_NAMES_LENGTH);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJECTS_REGISTRY: ");
test_printn(CH_CFG_FACTORY_OBJECTS_REGISTRY);
test_println("");
test_print("--- CH_CFG_FACTORY_GENERIC_BUFFERS: ");
test_printn(CH_CFG_FACTORY_GENERIC_BUFFERS);
test_println("");
test_print("--- CH_CFG_FACTORY_SEMAPHORES: ");
test_printn(CH_CFG_FACTORY_SEMAPHORES);
test_println("");
test_print("--- CH_CFG_FACTORY_MAILBOXES: ");
test_printn(CH_CFG_FACTORY_MAILBOXES);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJ_FIFOS: ");
test_printn(CH_CFG_FACTORY_OBJ_FIFOS);
test_println("");
test_print("--- CH_CFG_USE_PIPES: ");
test_printn(CH_CFG_USE_PIPES);
test_println(""); test_println("");
test_print("--- CH_DBG_STATISTICS: "); test_print("--- CH_DBG_STATISTICS: ");
test_printn(CH_DBG_STATISTICS); test_printn(CH_DBG_STATISTICS);

207
test/oslib/configuration.xml
View File

@ -45,6 +45,213 @@
</global_code> </global_code>
</global_data_and_code> </global_data_and_code>
<sequences> <sequences>
<sequence>
<type index="0">
<value>Internal Tests</value>
</type>
<brief>
<value>Information.</value>
</brief>
<description>
<value>This sequence reports configuration and version information about the OS library.</value>
</description>
<condition>
<value />
</condition>
<shared_code>
<value><![CDATA[#include "ch.h"]]></value>
</shared_code>
<cases>
<case>
<brief>
<value>Port Info.</value>
</brief>
<description>
<value>Port-related info are reported.</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>Prints the version string.</value>
</description>
<tags>
<value />
</tags>
<code>
<value><![CDATA[#if defined(PORT_ARCHITECTURE_NAME)
test_print("--- Architecture: ");
test_println(PORT_ARCHITECTURE_NAME);
#endif
#if defined(PORT_CORE_VARIANT_NAME)
test_print("--- Core Variant: ");
test_println(PORT_CORE_VARIANT_NAME);
#endif
#if defined(PORT_COMPILER_NAME)
test_print("--- Compiler: ");
test_println(PORT_COMPILER_NAME);
#endif
#if defined(PORT_INFO)
test_print("--- Port Info: ");
test_println(PORT_INFO);
#endif
#if defined(PORT_NATURAL_ALIGN)
test_print("--- Natural alignment: ");
test_printn(PORT_NATURAL_ALIGN);
test_println("");
#endif
#if defined(PORT_STACK_ALIGN)
test_print("--- Stack alignment: ");
test_printn(PORT_STACK_ALIGN);
test_println("");
#endif
#if defined(PORT_WORKING_AREA_ALIGN)
test_print("--- Working area alignment: ");
test_printn(PORT_WORKING_AREA_ALIGN);
test_println("");
#endif]]></value>
</code>
</step>
</steps>
</case>
<case>
<brief>
<value>OS Library Info.</value>
</brief>
<description>
<value>The version numbers are reported.</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>Prints the version string.</value>
</description>
<tags>
<value />
</tags>
<code>
<value><![CDATA[
test_println("--- Product: ChibiOS/LIB");
test_print("--- Stable Flag: ");
test_printn(CH_OSLIB_STABLE);
test_println("");
test_print("--- Version String: ");
test_println(CH_OSLIB_VERSION);
test_print("--- Major Number: ");
test_printn(CH_OSLIB_MAJOR);
test_println("");
test_print("--- Minor Number: ");
test_printn(CH_OSLIB_MINOR);
test_println("");
test_print("--- Patch Number: ");
test_printn(CH_OSLIB_PATCH);
test_println("");]]></value>
</code>
</step>
</steps>
</case>
<case>
<brief>
<value>OS Library Settings.</value>
</brief>
<description>
<value>The static OS Library settings are reported.</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>Prints the configuration options settings.</value>
</description>
<tags>
<value />
</tags>
<code>
<value><![CDATA[test_print("--- CH_CFG_USE_MEMCORE: ");
test_printn(CH_CFG_USE_MEMCORE);
test_println("");
test_print("--- CH_CFG_USE_HEAP: ");
test_printn(CH_CFG_USE_HEAP);
test_println("");
test_print("--- CH_CFG_USE_MEMPOOLS: ");
test_printn(CH_CFG_USE_MEMPOOLS);
test_println("");
test_print("--- CH_CFG_USE_OBJ_FIFOS: ");
test_printn(CH_CFG_USE_OBJ_FIFOS);
test_println("");
test_print("--- CH_CFG_USE_PIPES: ");
test_printn(CH_CFG_USE_PIPES);
test_println("");
test_print("--- CH_CFG_USE_FACTORY: ");
test_printn(CH_CFG_USE_FACTORY);
test_println("");
test_print("--- CH_CFG_FACTORY_MAX_NAMES_LENGTH: ");
test_printn(CH_CFG_FACTORY_MAX_NAMES_LENGTH);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJECTS_REGISTRY: ");
test_printn(CH_CFG_FACTORY_OBJECTS_REGISTRY);
test_println("");
test_print("--- CH_CFG_FACTORY_GENERIC_BUFFERS: ");
test_printn(CH_CFG_FACTORY_GENERIC_BUFFERS);
test_println("");
test_print("--- CH_CFG_FACTORY_SEMAPHORES: ");
test_printn(CH_CFG_FACTORY_SEMAPHORES);
test_println("");
test_print("--- CH_CFG_FACTORY_MAILBOXES: ");
test_printn(CH_CFG_FACTORY_MAILBOXES);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJ_FIFOS: ");
test_printn(CH_CFG_FACTORY_OBJ_FIFOS);
test_println("");
test_print("--- CH_CFG_FACTORY_PIPES: ");
test_printn(CH_CFG_FACTORY_PIPES);
test_println("");]]></value>
</code>
</step>
</steps>
</case>
</cases>
</sequence>
<sequence> <sequence>
<type index="0"> <type index="0">
<value>Internal Tests</value> <value>Internal Tests</value>

3
test/oslib/oslib_test.mk
View File

@ -4,7 +4,8 @@ TESTSRC += ${CHIBIOS}/test/oslib/source/test/oslib_test_root.c \
${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_002.c \ ${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_002.c \
${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_003.c \ ${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_003.c \
${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_004.c \ ${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_004.c \
${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_005.c ${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_005.c \
${CHIBIOS}/test/oslib/source/test/oslib_test_sequence_006.c
# Required include directories # Required include directories
TESTINC += ${CHIBIOS}/test/oslib/source/test TESTINC += ${CHIBIOS}/test/oslib/source/test

14
test/oslib/source/test/oslib_test_root.c
View File

@ -26,6 +26,7 @@
* - @subpage oslib_test_sequence_003 * - @subpage oslib_test_sequence_003
* - @subpage oslib_test_sequence_004 * - @subpage oslib_test_sequence_004
* - @subpage oslib_test_sequence_005 * - @subpage oslib_test_sequence_005
* - @subpage oslib_test_sequence_006
* . * .
*/ */
@ -47,20 +48,21 @@
* @brief Array of test sequences. * @brief Array of test sequences.
*/ */
const testsequence_t * const oslib_test_suite_array[] = { const testsequence_t * const oslib_test_suite_array[] = {
#if (CH_CFG_USE_MAILBOXES) || defined(__DOXYGEN__)
&oslib_test_sequence_001, &oslib_test_sequence_001,
#endif #if (CH_CFG_USE_MAILBOXES) || defined(__DOXYGEN__)
#if (CH_CFG_USE_PIPES) || defined(__DOXYGEN__)
&oslib_test_sequence_002, &oslib_test_sequence_002,
#endif #endif
#if (CH_CFG_USE_MEMPOOLS) || defined(__DOXYGEN__) #if (CH_CFG_USE_PIPES) || defined(__DOXYGEN__)
&oslib_test_sequence_003, &oslib_test_sequence_003,
#endif #endif
#if (CH_CFG_USE_HEAP) || defined(__DOXYGEN__) #if (CH_CFG_USE_MEMPOOLS) || defined(__DOXYGEN__)
&oslib_test_sequence_004, &oslib_test_sequence_004,
#endif #endif
#if ((CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE)) || defined(__DOXYGEN__) #if (CH_CFG_USE_HEAP) || defined(__DOXYGEN__)
&oslib_test_sequence_005, &oslib_test_sequence_005,
#endif
#if ((CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE)) || defined(__DOXYGEN__)
&oslib_test_sequence_006,
#endif #endif
NULL NULL
}; };

1
test/oslib/source/test/oslib_test_root.h
View File

@ -29,6 +29,7 @@
#include "oslib_test_sequence_003.h" #include "oslib_test_sequence_003.h"
#include "oslib_test_sequence_004.h" #include "oslib_test_sequence_004.h"
#include "oslib_test_sequence_005.h" #include "oslib_test_sequence_005.h"
#include "oslib_test_sequence_006.h"
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)

408
test/oslib/source/test/oslib_test_sequence_001.c
View File

@ -21,19 +21,13 @@
* @file oslib_test_sequence_001.c * @file oslib_test_sequence_001.c
* @brief Test Sequence 001 code. * @brief Test Sequence 001 code.
* *
* @page oslib_test_sequence_001 [1] Mailboxes * @page oslib_test_sequence_001 [1] Information
* *
* File: @ref oslib_test_sequence_001.c * File: @ref oslib_test_sequence_001.c
* *
* <h2>Description</h2> * <h2>Description</h2>
* This sequence tests the ChibiOS library functionalities related to * This sequence reports configuration and version information about
* mailboxes. * the OS library.
*
* <h2>Conditions</h2>
* This sequence is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_MAILBOXES
* .
* *
* <h2>Test Cases</h2> * <h2>Test Cases</h2>
* - @subpage oslib_test_001_001 * - @subpage oslib_test_001_001
@ -42,352 +36,176 @@
* . * .
*/ */
#if (CH_CFG_USE_MAILBOXES) || defined(__DOXYGEN__)
/**************************************************************************** /****************************************************************************
* Shared code. * Shared code.
****************************************************************************/ ****************************************************************************/
#define MB_SIZE 4 #include "ch.h"
static msg_t mb_buffer[MB_SIZE];
static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);
/**************************************************************************** /****************************************************************************
* Test cases. * Test cases.
****************************************************************************/ ****************************************************************************/
/** /**
* @page oslib_test_001_001 [1.1] Mailbox normal API, non-blocking tests * @page oslib_test_001_001 [1.1] Port Info
* *
* <h2>Description</h2> * <h2>Description</h2>
* The mailbox normal API is tested without triggering blocking * Port-related info are reported.
* conditions.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [1.1.1] Testing the mailbox size. * - [1.1.1] Prints the version string.
* - [1.1.2] Resetting the mailbox, conditions are checked, no errors
* expected.
* - [1.1.3] Testing the behavior of API when the mailbox is in reset
* state then return in active state.
* - [1.1.4] Filling the mailbox using chMBPostTimeout() and
* chMBPostAheadTimeout() once, no errors expected.
* - [1.1.5] Testing intermediate conditions. Data pointers must be
* aligned, semaphore counters are checked.
* - [1.1.6] Emptying the mailbox using chMBFetchTimeout(), no errors
* expected.
* - [1.1.7] Posting and then fetching one more message, no errors
* expected.
* - [1.1.8] Testing final conditions. Data pointers must be aligned to
* buffer start, semaphore counters are checked.
* . * .
*/ */
static void oslib_test_001_001_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void oslib_test_001_001_teardown(void) {
chMBReset(&mb1);
}
static void oslib_test_001_001_execute(void) { static void oslib_test_001_001_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [1.1.1] Testing the mailbox size.*/ /* [1.1.1] Prints the version string.*/
test_set_step(1); test_set_step(1);
{ {
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size"); #if defined(PORT_ARCHITECTURE_NAME)
} test_print("--- Architecture: ");
test_println(PORT_ARCHITECTURE_NAME);
/* [1.1.2] Resetting the mailbox, conditions are checked, no errors #endif
expected.*/ #if defined(PORT_CORE_VARIANT_NAME)
test_set_step(2); test_print("--- Core Variant: ");
{ test_println(PORT_CORE_VARIANT_NAME);
chMBReset(&mb1); #endif
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty"); #if defined(PORT_COMPILER_NAME)
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full"); test_print("--- Compiler: ");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base"); test_println(PORT_COMPILER_NAME);
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base"); #endif
} #if defined(PORT_INFO)
test_print("--- Port Info: ");
/* [1.1.3] Testing the behavior of API when the mailbox is in reset test_println(PORT_INFO);
state then return in active state.*/ #endif
test_set_step(3); #if defined(PORT_NATURAL_ALIGN)
{ test_print("--- Natural alignment: ");
msg1 = chMBPostTimeout(&mb1, (msg_t)0, TIME_INFINITE); test_printn(PORT_NATURAL_ALIGN);
test_assert(msg1 == MSG_RESET, "not in reset state"); test_println("");
msg1 = chMBPostAheadTimeout(&mb1, (msg_t)0, TIME_INFINITE); #endif
test_assert(msg1 == MSG_RESET, "not in reset state"); #if defined(PORT_STACK_ALIGN)
msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE); test_print("--- Stack alignment: ");
test_assert(msg1 == MSG_RESET, "not in reset state"); test_printn(PORT_STACK_ALIGN);
chMBResumeX(&mb1); test_println("");
} #endif
#if defined(PORT_WORKING_AREA_ALIGN)
/* [1.1.4] Filling the mailbox using chMBPostTimeout() and test_print("--- Working area alignment: ");
chMBPostAheadTimeout() once, no errors expected.*/ test_printn(PORT_WORKING_AREA_ALIGN);
test_set_step(4); test_println("");
{ #endif
for (i = 0; i < MB_SIZE - 1; i++) {
msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
msg1 = chMBPostAheadTimeout(&mb1, 'A', TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [1.1.5] Testing intermediate conditions. Data pointers must be
aligned, semaphore counters are checked.*/
test_set_step(5);
{
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");
}
/* [1.1.6] Emptying the mailbox using chMBFetchTimeout(), no errors
expected.*/
test_set_step(6);
{
for (i = 0; i < MB_SIZE; i++) {
msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
test_emit_token(msg2);
}
test_assert_sequence("ABCD", "wrong get sequence");
}
/* [1.1.7] Posting and then fetching one more message, no errors
expected.*/
test_set_step(7);
{
msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [1.1.8] Testing final conditions. Data pointers must be aligned to
buffer start, semaphore counters are checked.*/
test_set_step(8);
{
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");
} }
} }
static const testcase_t oslib_test_001_001 = { static const testcase_t oslib_test_001_001 = {
"Mailbox normal API, non-blocking tests", "Port Info",
oslib_test_001_001_setup, NULL,
oslib_test_001_001_teardown, NULL,
oslib_test_001_001_execute oslib_test_001_001_execute
}; };
/** /**
* @page oslib_test_001_002 [1.2] Mailbox I-Class API, non-blocking tests * @page oslib_test_001_002 [1.2] OS Library Info
* *
* <h2>Description</h2> * <h2>Description</h2>
* The mailbox I-Class API is tested without triggering blocking * The version numbers are reported.
* conditions.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [1.2.1] Testing the mailbox size. * - [1.2.1] Prints the version string.
* - [1.2.2] Resetting the mailbox, conditions are checked, no errors
* expected. The mailbox is then returned in active state.
* - [1.2.3] Filling the mailbox using chMBPostI() and chMBPostAheadI()
* once, no errors expected.
* - [1.2.4] Testing intermediate conditions. Data pointers must be
* aligned, semaphore counters are checked.
* - [1.2.5] Emptying the mailbox using chMBFetchI(), no errors
* expected.
* - [1.2.6] Posting and then fetching one more message, no errors
* expected.
* - [1.2.7] Testing final conditions. Data pointers must be aligned to
* buffer start, semaphore counters are checked.
* . * .
*/ */
static void oslib_test_001_002_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void oslib_test_001_002_teardown(void) {
chMBReset(&mb1);
}
static void oslib_test_001_002_execute(void) { static void oslib_test_001_002_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [1.2.1] Testing the mailbox size.*/ /* [1.2.1] Prints the version string.*/
test_set_step(1); test_set_step(1);
{ {
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size"); test_println("--- Product: ChibiOS/LIB");
} test_print("--- Stable Flag: ");
test_printn(CH_OSLIB_STABLE);
/* [1.2.2] Resetting the mailbox, conditions are checked, no errors test_println("");
expected. The mailbox is then returned in active state.*/ test_print("--- Version String: ");
test_set_step(2); test_println(CH_OSLIB_VERSION);
{ test_print("--- Major Number: ");
chSysLock(); test_printn(CH_OSLIB_MAJOR);
chMBResetI(&mb1); test_println("");
chSysUnlock(); test_print("--- Minor Number: ");
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty"); test_printn(CH_OSLIB_MINOR);
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full"); test_println("");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base"); test_print("--- Patch Number: ");
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base"); test_printn(CH_OSLIB_PATCH);
chMBResumeX(&mb1); test_println("");
}
/* [1.2.3] 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");
}
/* [1.2.4] 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");
}
/* [1.2.5] 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("ABCD", "wrong get sequence");
}
/* [1.2.6] Posting and then fetching one more message, no errors
expected.*/
test_set_step(6);
{
msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [1.2.7] Testing final conditions. Data pointers must be aligned to
buffer start, semaphore counters are checked.*/
test_set_step(7);
{
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");
} }
} }
static const testcase_t oslib_test_001_002 = { static const testcase_t oslib_test_001_002 = {
"Mailbox I-Class API, non-blocking tests", "OS Library Info",
oslib_test_001_002_setup, NULL,
oslib_test_001_002_teardown, NULL,
oslib_test_001_002_execute oslib_test_001_002_execute
}; };
/** /**
* @page oslib_test_001_003 [1.3] Mailbox timeouts * @page oslib_test_001_003 [1.3] OS Library Settings
* *
* <h2>Description</h2> * <h2>Description</h2>
* The mailbox API is tested for timeouts. * The static OS Library settings are reported.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [1.3.1] Filling the mailbox. * - [1.3.1] Prints the configuration options settings.
* - [1.3.2] Testing chMBPostTimeout(), chMBPostI(),
* chMBPostAheadTimeout() and chMBPostAheadI() timeout.
* - [1.3.3] Resetting the mailbox. The mailbox is then returned in
* active state.
* - [1.3.4] Testing chMBFetchTimeout() and chMBFetchI() timeout.
* . * .
*/ */
static void oslib_test_001_003_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void oslib_test_001_003_teardown(void) {
chMBReset(&mb1);
}
static void oslib_test_001_003_execute(void) { static void oslib_test_001_003_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [1.3.1] Filling the mailbox.*/ /* [1.3.1] Prints the configuration options settings.*/
test_set_step(1); test_set_step(1);
{ {
for (i = 0; i < MB_SIZE; i++) { test_print("--- CH_CFG_USE_MEMCORE: ");
msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE); test_printn(CH_CFG_USE_MEMCORE);
test_assert(msg1 == MSG_OK, "wrong wake-up message"); test_println("");
} test_print("--- CH_CFG_USE_HEAP: ");
} test_printn(CH_CFG_USE_HEAP);
test_println("");
/* [1.3.2] Testing chMBPostTimeout(), chMBPostI(), test_print("--- CH_CFG_USE_MEMPOOLS: ");
chMBPostAheadTimeout() and chMBPostAheadI() timeout.*/ test_printn(CH_CFG_USE_MEMPOOLS);
test_set_step(2); test_println("");
{ test_print("--- CH_CFG_USE_OBJ_FIFOS: ");
msg1 = chMBPostTimeout(&mb1, 'X', 1); test_printn(CH_CFG_USE_OBJ_FIFOS);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message"); test_println("");
chSysLock(); test_print("--- CH_CFG_USE_PIPES: ");
msg1 = chMBPostI(&mb1, 'X'); test_printn(CH_CFG_USE_PIPES);
chSysUnlock(); test_println("");
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message"); test_print("--- CH_CFG_USE_FACTORY: ");
msg1 = chMBPostAheadTimeout(&mb1, 'X', 1); test_printn(CH_CFG_USE_FACTORY);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message"); test_println("");
chSysLock(); test_print("--- CH_CFG_FACTORY_MAX_NAMES_LENGTH: ");
msg1 = chMBPostAheadI(&mb1, 'X'); test_printn(CH_CFG_FACTORY_MAX_NAMES_LENGTH);
chSysUnlock(); test_println("");
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message"); test_print("--- CH_CFG_FACTORY_OBJECTS_REGISTRY: ");
} test_printn(CH_CFG_FACTORY_OBJECTS_REGISTRY);
test_println("");
/* [1.3.3] Resetting the mailbox. The mailbox is then returned in test_print("--- CH_CFG_FACTORY_GENERIC_BUFFERS: ");
active state.*/ test_printn(CH_CFG_FACTORY_GENERIC_BUFFERS);
test_set_step(3); test_println("");
{ test_print("--- CH_CFG_FACTORY_SEMAPHORES: ");
chMBReset(&mb1); test_printn(CH_CFG_FACTORY_SEMAPHORES);
chMBResumeX(&mb1); test_println("");
} test_print("--- CH_CFG_FACTORY_MAILBOXES: ");
test_printn(CH_CFG_FACTORY_MAILBOXES);
/* [1.3.4] Testing chMBFetchTimeout() and chMBFetchI() timeout.*/ test_println("");
test_set_step(4); test_print("--- CH_CFG_FACTORY_OBJ_FIFOS: ");
{ test_printn(CH_CFG_FACTORY_OBJ_FIFOS);
msg1 = chMBFetchTimeout(&mb1, &msg2, 1); test_println("");
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message"); test_print("--- CH_CFG_FACTORY_PIPES: ");
chSysLock(); test_printn(CH_CFG_FACTORY_PIPES);
msg1 = chMBFetchI(&mb1, &msg2); test_println("");
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
} }
} }
static const testcase_t oslib_test_001_003 = { static const testcase_t oslib_test_001_003 = {
"Mailbox timeouts", "OS Library Settings",
oslib_test_001_003_setup, NULL,
oslib_test_001_003_teardown, NULL,
oslib_test_001_003_execute oslib_test_001_003_execute
}; };
@ -406,11 +224,9 @@ const testcase_t * const oslib_test_sequence_001_array[] = {
}; };
/** /**
* @brief Mailboxes. * @brief Information.
*/ */
const testsequence_t oslib_test_sequence_001 = { const testsequence_t oslib_test_sequence_001 = {
"Mailboxes", "Information",
oslib_test_sequence_001_array oslib_test_sequence_001_array
}; };
#endif /* CH_CFG_USE_MAILBOXES */

482
test/oslib/source/test/oslib_test_sequence_002.c
View File

@ -21,325 +21,376 @@
* @file oslib_test_sequence_002.c * @file oslib_test_sequence_002.c
* @brief Test Sequence 002 code. * @brief Test Sequence 002 code.
* *
* @page oslib_test_sequence_002 [2] Pipes * @page oslib_test_sequence_002 [2] Mailboxes
* *
* File: @ref oslib_test_sequence_002.c * File: @ref oslib_test_sequence_002.c
* *
* <h2>Description</h2> * <h2>Description</h2>
* This sequence tests the ChibiOS library functionalities related to * This sequence tests the ChibiOS library functionalities related to
* pipes. * mailboxes.
* *
* <h2>Conditions</h2> * <h2>Conditions</h2>
* This sequence is only executed if the following preprocessor condition * This sequence is only executed if the following preprocessor condition
* evaluates to true: * evaluates to true:
* - CH_CFG_USE_PIPES * - CH_CFG_USE_MAILBOXES
* . * .
* *
* <h2>Test Cases</h2> * <h2>Test Cases</h2>
* - @subpage oslib_test_002_001 * - @subpage oslib_test_002_001
* - @subpage oslib_test_002_002 * - @subpage oslib_test_002_002
* - @subpage oslib_test_002_003
* . * .
*/ */
#if (CH_CFG_USE_PIPES) || defined(__DOXYGEN__) #if (CH_CFG_USE_MAILBOXES) || defined(__DOXYGEN__)
/**************************************************************************** /****************************************************************************
* Shared code. * Shared code.
****************************************************************************/ ****************************************************************************/
#include <string.h> #define MB_SIZE 4
#define PIPE_SIZE 16 static msg_t mb_buffer[MB_SIZE];
static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);
static uint8_t buffer[PIPE_SIZE];
static PIPE_DECL(pipe1, buffer, PIPE_SIZE);
static const uint8_t pipe_pattern[] = "0123456789ABCDEF";
/**************************************************************************** /****************************************************************************
* Test cases. * Test cases.
****************************************************************************/ ****************************************************************************/
/** /**
* @page oslib_test_002_001 [2.1] Pipes normal API, non-blocking tests * @page oslib_test_002_001 [2.1] Mailbox normal API, non-blocking tests
* *
* <h2>Description</h2> * <h2>Description</h2>
* The pipe functionality is tested by loading and emptying it, all * The mailbox normal API is tested without triggering blocking
* conditions are tested. * conditions.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [2.1.1] Resetting pipe. * - [2.1.1] Testing the mailbox size.
* - [2.1.2] Writing data, must fail. * - [2.1.2] Resetting the mailbox, conditions are checked, no errors
* - [2.1.3] Reading data, must fail. * expected.
* - [2.1.4] Reactivating pipe. * - [2.1.3] Testing the behavior of API when the mailbox is in reset
* - [2.1.5] Filling whole pipe. * state then return in active state.
* - [2.1.6] Emptying pipe. * - [2.1.4] Filling the mailbox using chMBPostTimeout() and
* - [2.1.7] Small write. * chMBPostAheadTimeout() once, no errors expected.
* - [2.1.8] Filling remaining space. * - [2.1.5] Testing intermediate conditions. Data pointers must be
* - [2.1.9] Small Read. * aligned, semaphore counters are checked.
* - [2.1.10] Reading remaining data. * - [2.1.6] Emptying the mailbox using chMBFetchTimeout(), no errors
* - [2.1.11] Small Write. * expected.
* - [2.1.12] Small Read. * - [2.1.7] Posting and then fetching one more message, no errors
* - [2.1.13] Write wrapping buffer boundary. * expected.
* - [2.1.14] Read wrapping buffer boundary. * - [2.1.8] Testing final conditions. Data pointers must be aligned to
* buffer start, semaphore counters are checked.
* . * .
*/ */
static void oslib_test_002_001_setup(void) { static void oslib_test_002_001_setup(void) {
chPipeObjectInit(&pipe1, buffer, PIPE_SIZE); chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void oslib_test_002_001_teardown(void) {
chMBReset(&mb1);
} }
static void oslib_test_002_001_execute(void) { static void oslib_test_002_001_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [2.1.1] Resetting pipe.*/ /* [2.1.1] Testing the mailbox size.*/
test_set_step(1); test_set_step(1);
{ {
chPipeReset(&pipe1); test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [2.1.2] Writing data, must fail.*/ /* [2.1.2] Resetting the mailbox, conditions are checked, no errors
expected.*/
test_set_step(2); test_set_step(2);
{ {
size_t n; chMBReset(&mb1);
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE); test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert(n == 0, "not reset"); test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert((pipe1.rdptr == pipe1.buffer) && test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [2.1.3] Reading data, must fail.*/ /* [2.1.3] Testing the behavior of API when the mailbox is in reset
state then return in active state.*/
test_set_step(3); test_set_step(3);
{ {
size_t n; msg1 = chMBPostTimeout(&mb1, (msg_t)0, TIME_INFINITE);
uint8_t buf[PIPE_SIZE]; test_assert(msg1 == MSG_RESET, "not in reset state");
msg1 = chMBPostAheadTimeout(&mb1, (msg_t)0, TIME_INFINITE);
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE); test_assert(msg1 == MSG_RESET, "not in reset state");
test_assert(n == 0, "not reset"); msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE);
test_assert((pipe1.rdptr == pipe1.buffer) && test_assert(msg1 == MSG_RESET, "not in reset state");
(pipe1.wrptr == pipe1.buffer) && chMBResumeX(&mb1);
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [2.1.4] Reactivating pipe.*/ /* [2.1.4] Filling the mailbox using chMBPostTimeout() and
chMBPostAheadTimeout() once, no errors expected.*/
test_set_step(4); test_set_step(4);
{ {
chPipeResume(&pipe1); for (i = 0; i < MB_SIZE - 1; i++) {
test_assert((pipe1.rdptr == pipe1.buffer) && msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE);
(pipe1.wrptr == pipe1.buffer) && test_assert(msg1 == MSG_OK, "wrong wake-up message");
(pipe1.cnt == 0), }
"invalid pipe state"); msg1 = chMBPostAheadTimeout(&mb1, 'A', TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
} }
/* [2.1.5] Filling whole pipe.*/ /* [2.1.5] Testing intermediate conditions. Data pointers must be
aligned, semaphore counters are checked.*/
test_set_step(5); test_set_step(5);
{ {
size_t n; test_assert_lock(chMBGetFreeCountI(&mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not full");
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE); test_assert_lock(mb1.rdptr == mb1.wrptr, "pointers not aligned");
test_assert(n == PIPE_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE),
"invalid pipe state");
} }
/* [2.1.6] Emptying pipe.*/ /* [2.1.6] Emptying the mailbox using chMBFetchTimeout(), no errors
expected.*/
test_set_step(6); test_set_step(6);
{ {
size_t n; for (i = 0; i < MB_SIZE; i++) {
uint8_t buf[PIPE_SIZE]; msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE); test_emit_token(msg2);
test_assert(n == PIPE_SIZE, "wrong size"); }
test_assert((pipe1.rdptr == pipe1.buffer) && test_assert_sequence("ABCD", "wrong get sequence");
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, PIPE_SIZE) == 0, "content mismatch");
} }
/* [2.1.7] Small write.*/ /* [2.1.7] Posting and then fetching one more message, no errors
expected.*/
test_set_step(7); test_set_step(7);
{ {
size_t n; msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
n = chPipeWriteTimeout(&pipe1, pipe_pattern, 4, TIME_IMMEDIATE); msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE);
test_assert(n == 4, "wrong size"); test_assert(msg1 == MSG_OK, "wrong wake-up message");
test_assert((pipe1.rdptr != pipe1.wrptr) &&
(pipe1.rdptr == pipe1.buffer) &&
(pipe1.cnt == 4),
"invalid pipe state");
} }
/* [2.1.8] Filling remaining space.*/ /* [2.1.8] Testing final conditions. Data pointers must be aligned to
buffer start, semaphore counters are checked.*/
test_set_step(8); test_set_step(8);
{ {
size_t n; test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE - 4, TIME_IMMEDIATE); test_assert(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert(n == PIPE_SIZE - 4, "wrong size"); test_assert(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE),
"invalid pipe state");
}
/* [2.1.9] Small Read.*/
test_set_step(9);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, 4, TIME_IMMEDIATE);
test_assert(n == 4, "wrong size");
test_assert((pipe1.rdptr != pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE - 4),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, 4) == 0, "content mismatch");
}
/* [2.1.10] Reading remaining data.*/
test_set_step(10);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE - 4, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE - 4, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, PIPE_SIZE - 4) == 0, "content mismatch");
}
/* [2.1.11] Small Write.*/
test_set_step(11);
{
size_t n;
n = chPipeWriteTimeout(&pipe1, pipe_pattern, 5, TIME_IMMEDIATE);
test_assert(n == 5, "wrong size");
test_assert((pipe1.rdptr != pipe1.wrptr) &&
(pipe1.rdptr == pipe1.buffer) &&
(pipe1.cnt == 5),
"invalid pipe state");
}
/* [2.1.12] Small Read.*/
test_set_step(12);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, 5, TIME_IMMEDIATE);
test_assert(n == 5, "wrong size");
test_assert((pipe1.rdptr == pipe1.wrptr) &&
(pipe1.wrptr != pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, 5) == 0, "content mismatch");
}
/* [2.1.13] Write wrapping buffer boundary.*/
test_set_step(13);
{
size_t n;
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.wrptr) &&
(pipe1.wrptr != pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE),
"invalid pipe state");
}
/* [2.1.14] Read wrapping buffer boundary.*/
test_set_step(14);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.wrptr) &&
(pipe1.wrptr != pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, PIPE_SIZE) == 0, "content mismatch");
} }
} }
static const testcase_t oslib_test_002_001 = { static const testcase_t oslib_test_002_001 = {
"Pipes normal API, non-blocking tests", "Mailbox normal API, non-blocking tests",
oslib_test_002_001_setup, oslib_test_002_001_setup,
NULL, oslib_test_002_001_teardown,
oslib_test_002_001_execute oslib_test_002_001_execute
}; };
/** /**
* @page oslib_test_002_002 [2.2] Pipe timeouts * @page oslib_test_002_002 [2.2] Mailbox I-Class API, non-blocking tests
* *
* <h2>Description</h2> * <h2>Description</h2>
* The pipe API is tested for timeouts. * The mailbox I-Class API is tested without triggering blocking
* conditions.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [2.2.1] Reading while pipe is empty. * - [2.2.1] Testing the mailbox size.
* - [2.2.2] Writing a string larger than pipe buffer. * - [2.2.2] Resetting the mailbox, conditions are checked, no errors
* expected. The mailbox is then returned in active state.
* - [2.2.3] Filling the mailbox using chMBPostI() and chMBPostAheadI()
* once, no errors expected.
* - [2.2.4] Testing intermediate conditions. Data pointers must be
* aligned, semaphore counters are checked.
* - [2.2.5] Emptying the mailbox using chMBFetchI(), no errors
* expected.
* - [2.2.6] Posting and then fetching one more message, no errors
* expected.
* - [2.2.7] Testing final conditions. Data pointers must be aligned to
* buffer start, semaphore counters are checked.
* . * .
*/ */
static void oslib_test_002_002_setup(void) { static void oslib_test_002_002_setup(void) {
chPipeObjectInit(&pipe1, buffer, PIPE_SIZE / 2); chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void oslib_test_002_002_teardown(void) {
chMBReset(&mb1);
} }
static void oslib_test_002_002_execute(void) { static void oslib_test_002_002_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [2.2.1] Reading while pipe is empty.*/ /* [2.2.1] Testing the mailbox size.*/
test_set_step(1); test_set_step(1);
{ {
size_t n; test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == 0, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [2.2.2] Writing a string larger than pipe buffer.*/ /* [2.2.2] Resetting the mailbox, conditions are checked, no errors
expected. The mailbox is then returned in active state.*/
test_set_step(2); test_set_step(2);
{ {
size_t n; 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");
chMBResumeX(&mb1);
}
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE); /* [2.2.3] Filling the mailbox using chMBPostI() and chMBPostAheadI()
test_assert(n == PIPE_SIZE / 2, "wrong size"); once, no errors expected.*/
test_assert((pipe1.rdptr == pipe1.wrptr) && test_set_step(3);
(pipe1.wrptr == pipe1.buffer) && {
(pipe1.cnt == PIPE_SIZE / 2), for (i = 0; i < MB_SIZE - 1; i++) {
"invalid pipe state"); 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");
}
/* [2.2.4] 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");
}
/* [2.2.5] 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("ABCD", "wrong get sequence");
}
/* [2.2.6] Posting and then fetching one more message, no errors
expected.*/
test_set_step(6);
{
msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetchTimeout(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
/* [2.2.7] Testing final conditions. Data pointers must be aligned to
buffer start, semaphore counters are checked.*/
test_set_step(7);
{
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");
} }
} }
static const testcase_t oslib_test_002_002 = { static const testcase_t oslib_test_002_002 = {
"Pipe timeouts", "Mailbox I-Class API, non-blocking tests",
oslib_test_002_002_setup, oslib_test_002_002_setup,
NULL, oslib_test_002_002_teardown,
oslib_test_002_002_execute oslib_test_002_002_execute
}; };
/**
* @page oslib_test_002_003 [2.3] Mailbox timeouts
*
* <h2>Description</h2>
* The mailbox API is tested for timeouts.
*
* <h2>Test Steps</h2>
* - [2.3.1] Filling the mailbox.
* - [2.3.2] Testing chMBPostTimeout(), chMBPostI(),
* chMBPostAheadTimeout() and chMBPostAheadI() timeout.
* - [2.3.3] Resetting the mailbox. The mailbox is then returned in
* active state.
* - [2.3.4] Testing chMBFetchTimeout() and chMBFetchI() timeout.
* .
*/
static void oslib_test_002_003_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
static void oslib_test_002_003_teardown(void) {
chMBReset(&mb1);
}
static void oslib_test_002_003_execute(void) {
msg_t msg1, msg2;
unsigned i;
/* [2.3.1] Filling the mailbox.*/
test_set_step(1);
{
for (i = 0; i < MB_SIZE; i++) {
msg1 = chMBPostTimeout(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
}
/* [2.3.2] Testing chMBPostTimeout(), chMBPostI(),
chMBPostAheadTimeout() and chMBPostAheadI() timeout.*/
test_set_step(2);
{
msg1 = chMBPostTimeout(&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 = chMBPostAheadTimeout(&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");
}
/* [2.3.3] Resetting the mailbox. The mailbox is then returned in
active state.*/
test_set_step(3);
{
chMBReset(&mb1);
chMBResumeX(&mb1);
}
/* [2.3.4] Testing chMBFetchTimeout() and chMBFetchI() timeout.*/
test_set_step(4);
{
msg1 = chMBFetchTimeout(&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 oslib_test_002_003 = {
"Mailbox timeouts",
oslib_test_002_003_setup,
oslib_test_002_003_teardown,
oslib_test_002_003_execute
};
/**************************************************************************** /****************************************************************************
* Exported data. * Exported data.
****************************************************************************/ ****************************************************************************/
@ -350,15 +401,16 @@ static const testcase_t oslib_test_002_002 = {
const testcase_t * const oslib_test_sequence_002_array[] = { const testcase_t * const oslib_test_sequence_002_array[] = {
&oslib_test_002_001, &oslib_test_002_001,
&oslib_test_002_002, &oslib_test_002_002,
&oslib_test_002_003,
NULL NULL
}; };
/** /**
* @brief Pipes. * @brief Mailboxes.
*/ */
const testsequence_t oslib_test_sequence_002 = { const testsequence_t oslib_test_sequence_002 = {
"Pipes", "Mailboxes",
oslib_test_sequence_002_array oslib_test_sequence_002_array
}; };
#endif /* CH_CFG_USE_PIPES */ #endif /* CH_CFG_USE_MAILBOXES */

369
test/oslib/source/test/oslib_test_sequence_003.c
View File

@ -21,258 +21,324 @@
* @file oslib_test_sequence_003.c * @file oslib_test_sequence_003.c
* @brief Test Sequence 003 code. * @brief Test Sequence 003 code.
* *
* @page oslib_test_sequence_003 [3] Memory Pools * @page oslib_test_sequence_003 [3] Pipes
* *
* File: @ref oslib_test_sequence_003.c * File: @ref oslib_test_sequence_003.c
* *
* <h2>Description</h2> * <h2>Description</h2>
* This sequence tests the ChibiOS library functionalities related to * This sequence tests the ChibiOS library functionalities related to
* memory pools. * pipes.
* *
* <h2>Conditions</h2> * <h2>Conditions</h2>
* This sequence is only executed if the following preprocessor condition * This sequence is only executed if the following preprocessor condition
* evaluates to true: * evaluates to true:
* - CH_CFG_USE_MEMPOOLS * - CH_CFG_USE_PIPES
* . * .
* *
* <h2>Test Cases</h2> * <h2>Test Cases</h2>
* - @subpage oslib_test_003_001 * - @subpage oslib_test_003_001
* - @subpage oslib_test_003_002 * - @subpage oslib_test_003_002
* - @subpage oslib_test_003_003
* . * .
*/ */
#if (CH_CFG_USE_MEMPOOLS) || defined(__DOXYGEN__) #if (CH_CFG_USE_PIPES) || defined(__DOXYGEN__)
/**************************************************************************** /****************************************************************************
* Shared code. * Shared code.
****************************************************************************/ ****************************************************************************/
#define MEMORY_POOL_SIZE 4 #include <string.h>
static uint32_t objects[MEMORY_POOL_SIZE]; #define PIPE_SIZE 16
static MEMORYPOOL_DECL(mp1, sizeof (uint32_t), PORT_NATURAL_ALIGN, NULL);
#if CH_CFG_USE_SEMAPHORES static uint8_t buffer[PIPE_SIZE];
static GUARDEDMEMORYPOOL_DECL(gmp1, sizeof (uint32_t), PORT_NATURAL_ALIGN); static PIPE_DECL(pipe1, buffer, PIPE_SIZE);
#endif
static void *null_provider(size_t size, unsigned align) { static const uint8_t pipe_pattern[] = "0123456789ABCDEF";
(void)size;
(void)align;
return NULL;
}
/**************************************************************************** /****************************************************************************
* Test cases. * Test cases.
****************************************************************************/ ****************************************************************************/
/** /**
* @page oslib_test_003_001 [3.1] Loading and emptying a memory pool * @page oslib_test_003_001 [3.1] Pipes normal API, non-blocking tests
* *
* <h2>Description</h2> * <h2>Description</h2>
* The memory pool functionality is tested by loading and emptying it, * The pipe functionality is tested by loading and emptying it, all
* all conditions are tested. * conditions are tested.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [3.1.1] Adding the objects to the pool using chPoolLoadArray(). * - [3.1.1] Resetting pipe.
* - [3.1.2] Emptying the pool using chPoolAlloc(). * - [3.1.2] Writing data, must fail.
* - [3.1.3] Now must be empty. * - [3.1.3] Reading data, must fail.
* - [3.1.4] Adding the objects to the pool using chPoolFree(). * - [3.1.4] Reactivating pipe.
* - [3.1.5] Emptying the pool using chPoolAlloc() again. * - [3.1.5] Filling whole pipe.
* - [3.1.6] Now must be empty again. * - [3.1.6] Emptying pipe.
* - [3.1.7] Covering the case where a provider is unable to return * - [3.1.7] Small write.
* more memory. * - [3.1.8] Filling remaining space.
* - [3.1.9] Small Read.
* - [3.1.10] Reading remaining data.
* - [3.1.11] Small Write.
* - [3.1.12] Small Read.
* - [3.1.13] Write wrapping buffer boundary.
* - [3.1.14] Read wrapping buffer boundary.
* . * .
*/ */
static void oslib_test_003_001_setup(void) { static void oslib_test_003_001_setup(void) {
chPoolObjectInit(&mp1, sizeof (uint32_t), NULL); chPipeObjectInit(&pipe1, buffer, PIPE_SIZE);
} }
static void oslib_test_003_001_execute(void) { static void oslib_test_003_001_execute(void) {
unsigned i;
/* [3.1.1] Adding the objects to the pool using chPoolLoadArray().*/ /* [3.1.1] Resetting pipe.*/
test_set_step(1); test_set_step(1);
{ {
chPoolLoadArray(&mp1, objects, MEMORY_POOL_SIZE); chPipeReset(&pipe1);
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [3.1.2] Emptying the pool using chPoolAlloc().*/ /* [3.1.2] Writing data, must fail.*/
test_set_step(2); test_set_step(2);
{ {
for (i = 0; i < MEMORY_POOL_SIZE; i++) size_t n;
test_assert(chPoolAlloc(&mp1) != NULL, "list empty");
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == 0, "not reset");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [3.1.3] Now must be empty.*/ /* [3.1.3] Reading data, must fail.*/
test_set_step(3); test_set_step(3);
{ {
test_assert(chPoolAlloc(&mp1) == NULL, "list not empty"); size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == 0, "not reset");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [3.1.4] Adding the objects to the pool using chPoolFree().*/ /* [3.1.4] Reactivating pipe.*/
test_set_step(4); test_set_step(4);
{ {
for (i = 0; i < MEMORY_POOL_SIZE; i++) chPipeResume(&pipe1);
chPoolFree(&mp1, &objects[i]); test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [3.1.5] Emptying the pool using chPoolAlloc() again.*/ /* [3.1.5] Filling whole pipe.*/
test_set_step(5); test_set_step(5);
{ {
for (i = 0; i < MEMORY_POOL_SIZE; i++) size_t n;
test_assert(chPoolAlloc(&mp1) != NULL, "list empty");
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE),
"invalid pipe state");
} }
/* [3.1.6] Now must be empty again.*/ /* [3.1.6] Emptying pipe.*/
test_set_step(6); test_set_step(6);
{ {
test_assert(chPoolAlloc(&mp1) == NULL, "list not empty"); size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, PIPE_SIZE) == 0, "content mismatch");
} }
/* [3.1.7] Covering the case where a provider is unable to return /* [3.1.7] Small write.*/
more memory.*/
test_set_step(7); test_set_step(7);
{ {
chPoolObjectInit(&mp1, sizeof (uint32_t), null_provider); size_t n;
test_assert(chPoolAlloc(&mp1) == NULL, "provider returned memory");
n = chPipeWriteTimeout(&pipe1, pipe_pattern, 4, TIME_IMMEDIATE);
test_assert(n == 4, "wrong size");
test_assert((pipe1.rdptr != pipe1.wrptr) &&
(pipe1.rdptr == pipe1.buffer) &&
(pipe1.cnt == 4),
"invalid pipe state");
}
/* [3.1.8] Filling remaining space.*/
test_set_step(8);
{
size_t n;
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE - 4, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE - 4, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE),
"invalid pipe state");
}
/* [3.1.9] Small Read.*/
test_set_step(9);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, 4, TIME_IMMEDIATE);
test_assert(n == 4, "wrong size");
test_assert((pipe1.rdptr != pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE - 4),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, 4) == 0, "content mismatch");
}
/* [3.1.10] Reading remaining data.*/
test_set_step(10);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE - 4, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE - 4, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, PIPE_SIZE - 4) == 0, "content mismatch");
}
/* [3.1.11] Small Write.*/
test_set_step(11);
{
size_t n;
n = chPipeWriteTimeout(&pipe1, pipe_pattern, 5, TIME_IMMEDIATE);
test_assert(n == 5, "wrong size");
test_assert((pipe1.rdptr != pipe1.wrptr) &&
(pipe1.rdptr == pipe1.buffer) &&
(pipe1.cnt == 5),
"invalid pipe state");
}
/* [3.1.12] Small Read.*/
test_set_step(12);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, 5, TIME_IMMEDIATE);
test_assert(n == 5, "wrong size");
test_assert((pipe1.rdptr == pipe1.wrptr) &&
(pipe1.wrptr != pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, 5) == 0, "content mismatch");
}
/* [3.1.13] Write wrapping buffer boundary.*/
test_set_step(13);
{
size_t n;
n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.wrptr) &&
(pipe1.wrptr != pipe1.buffer) &&
(pipe1.cnt == PIPE_SIZE),
"invalid pipe state");
}
/* [3.1.14] Read wrapping buffer boundary.*/
test_set_step(14);
{
size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == PIPE_SIZE, "wrong size");
test_assert((pipe1.rdptr == pipe1.wrptr) &&
(pipe1.wrptr != pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
test_assert(memcmp(pipe_pattern, buf, PIPE_SIZE) == 0, "content mismatch");
} }
} }
static const testcase_t oslib_test_003_001 = { static const testcase_t oslib_test_003_001 = {
"Loading and emptying a memory pool", "Pipes normal API, non-blocking tests",
oslib_test_003_001_setup, oslib_test_003_001_setup,
NULL, NULL,
oslib_test_003_001_execute oslib_test_003_001_execute
}; };
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
/** /**
* @page oslib_test_003_002 [3.2] Loading and emptying a guarded memory pool without waiting * @page oslib_test_003_002 [3.2] Pipe timeouts
* *
* <h2>Description</h2> * <h2>Description</h2>
* The memory pool functionality is tested by loading and emptying it, * The pipe API is tested for timeouts.
* all conditions are tested.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_SEMAPHORES
* .
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [3.2.1] Adding the objects to the pool using * - [3.2.1] Reading while pipe is empty.
* chGuardedPoolLoadArray(). * - [3.2.2] Writing a string larger than pipe buffer.
* - [3.2.2] Emptying the pool using chGuardedPoolAllocTimeout().
* - [3.2.3] Now must be empty.
* - [3.2.4] Adding the objects to the pool using chGuardedPoolFree().
* - [3.2.5] Emptying the pool using chGuardedPoolAllocTimeout() again.
* - [3.2.6] Now must be empty again.
* . * .
*/ */
static void oslib_test_003_002_setup(void) { static void oslib_test_003_002_setup(void) {
chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t)); chPipeObjectInit(&pipe1, buffer, PIPE_SIZE / 2);
} }
static void oslib_test_003_002_execute(void) { static void oslib_test_003_002_execute(void) {
unsigned i;
/* [3.2.1] Adding the objects to the pool using /* [3.2.1] Reading while pipe is empty.*/
chGuardedPoolLoadArray().*/
test_set_step(1); test_set_step(1);
{ {
chGuardedPoolLoadArray(&gmp1, objects, MEMORY_POOL_SIZE); size_t n;
uint8_t buf[PIPE_SIZE];
n = chPipeReadTimeout(&pipe1, buf, PIPE_SIZE, TIME_IMMEDIATE);
test_assert(n == 0, "wrong size");
test_assert((pipe1.rdptr == pipe1.buffer) &&
(pipe1.wrptr == pipe1.buffer) &&
(pipe1.cnt == 0),
"invalid pipe state");
} }
/* [3.2.2] Emptying the pool using chGuardedPoolAllocTimeout().*/ /* [3.2.2] Writing a string larger than pipe buffer.*/
test_set_step(2); test_set_step(2);
{ {
for (i = 0; i < MEMORY_POOL_SIZE; i++) size_t n;
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) != NULL, "list empty");
}
/* [3.2.3] Now must be empty.*/ n = chPipeWriteTimeout(&pipe1, pipe_pattern, PIPE_SIZE, TIME_IMMEDIATE);
test_set_step(3); test_assert(n == PIPE_SIZE / 2, "wrong size");
{ test_assert((pipe1.rdptr == pipe1.wrptr) &&
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty"); (pipe1.wrptr == pipe1.buffer) &&
} (pipe1.cnt == PIPE_SIZE / 2),
"invalid pipe state");
/* [3.2.4] Adding the objects to the pool using
chGuardedPoolFree().*/
test_set_step(4);
{
for (i = 0; i < MEMORY_POOL_SIZE; i++)
chGuardedPoolFree(&gmp1, &objects[i]);
}
/* [3.2.5] Emptying the pool using chGuardedPoolAllocTimeout()
again.*/
test_set_step(5);
{
for (i = 0; i < MEMORY_POOL_SIZE; i++)
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) != NULL, "list empty");
}
/* [3.2.6] Now must be empty again.*/
test_set_step(6);
{
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty");
} }
} }
static const testcase_t oslib_test_003_002 = { static const testcase_t oslib_test_003_002 = {
"Loading and emptying a guarded memory pool without waiting", "Pipe timeouts",
oslib_test_003_002_setup, oslib_test_003_002_setup,
NULL, NULL,
oslib_test_003_002_execute oslib_test_003_002_execute
}; };
#endif /* CH_CFG_USE_SEMAPHORES */
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
/**
* @page oslib_test_003_003 [3.3] Guarded Memory Pools timeout
*
* <h2>Description</h2>
* The timeout features for the Guarded Memory Pools is tested.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_SEMAPHORES
* .
*
* <h2>Test Steps</h2>
* - [3.3.1] Trying to allocate with 100mS timeout, must fail because
* the pool is empty.
* .
*/
static void oslib_test_003_003_setup(void) {
chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t));
}
static void oslib_test_003_003_execute(void) {
/* [3.3.1] Trying to allocate with 100mS timeout, must fail because
the pool is empty.*/
test_set_step(1);
{
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_MS2I(100)) == NULL, "list not empty");
}
}
static const testcase_t oslib_test_003_003 = {
"Guarded Memory Pools timeout",
oslib_test_003_003_setup,
NULL,
oslib_test_003_003_execute
};
#endif /* CH_CFG_USE_SEMAPHORES */
/**************************************************************************** /****************************************************************************
* Exported data. * Exported data.
@ -283,21 +349,16 @@ static const testcase_t oslib_test_003_003 = {
*/ */
const testcase_t * const oslib_test_sequence_003_array[] = { const testcase_t * const oslib_test_sequence_003_array[] = {
&oslib_test_003_001, &oslib_test_003_001,
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
&oslib_test_003_002, &oslib_test_003_002,
#endif
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
&oslib_test_003_003,
#endif
NULL NULL
}; };
/** /**
* @brief Memory Pools. * @brief Pipes.
*/ */
const testsequence_t oslib_test_sequence_003 = { const testsequence_t oslib_test_sequence_003 = {
"Memory Pools", "Pipes",
oslib_test_sequence_003_array oslib_test_sequence_003_array
}; };
#endif /* CH_CFG_USE_MEMPOOLS */ #endif /* CH_CFG_USE_PIPES */

301
test/oslib/source/test/oslib_test_sequence_004.c
View File

@ -21,240 +21,258 @@
* @file oslib_test_sequence_004.c * @file oslib_test_sequence_004.c
* @brief Test Sequence 004 code. * @brief Test Sequence 004 code.
* *
* @page oslib_test_sequence_004 [4] Memory Heaps * @page oslib_test_sequence_004 [4] Memory Pools
* *
* File: @ref oslib_test_sequence_004.c * File: @ref oslib_test_sequence_004.c
* *
* <h2>Description</h2> * <h2>Description</h2>
* This sequence tests the ChibiOS library functionalities related to * This sequence tests the ChibiOS library functionalities related to
* memory heaps. * memory pools.
* *
* <h2>Conditions</h2> * <h2>Conditions</h2>
* This sequence is only executed if the following preprocessor condition * This sequence is only executed if the following preprocessor condition
* evaluates to true: * evaluates to true:
* - CH_CFG_USE_HEAP * - CH_CFG_USE_MEMPOOLS
* . * .
* *
* <h2>Test Cases</h2> * <h2>Test Cases</h2>
* - @subpage oslib_test_004_001 * - @subpage oslib_test_004_001
* - @subpage oslib_test_004_002 * - @subpage oslib_test_004_002
* - @subpage oslib_test_004_003
* . * .
*/ */
#if (CH_CFG_USE_HEAP) || defined(__DOXYGEN__) #if (CH_CFG_USE_MEMPOOLS) || defined(__DOXYGEN__)
/**************************************************************************** /****************************************************************************
* Shared code. * Shared code.
****************************************************************************/ ****************************************************************************/
#define ALLOC_SIZE 16 #define MEMORY_POOL_SIZE 4
#define HEAP_SIZE (ALLOC_SIZE * 8)
static memory_heap_t test_heap; static uint32_t objects[MEMORY_POOL_SIZE];
static uint8_t test_heap_buffer[HEAP_SIZE]; static MEMORYPOOL_DECL(mp1, sizeof (uint32_t), PORT_NATURAL_ALIGN, NULL);
#if CH_CFG_USE_SEMAPHORES
static GUARDEDMEMORYPOOL_DECL(gmp1, sizeof (uint32_t), PORT_NATURAL_ALIGN);
#endif
static void *null_provider(size_t size, unsigned align) {
(void)size;
(void)align;
return NULL;
}
/**************************************************************************** /****************************************************************************
* Test cases. * Test cases.
****************************************************************************/ ****************************************************************************/
/** /**
* @page oslib_test_004_001 [4.1] Allocation and fragmentation * @page oslib_test_004_001 [4.1] Loading and emptying a memory pool
* *
* <h2>Description</h2> * <h2>Description</h2>
* Series of allocations/deallocations are performed in carefully * The memory pool functionality is tested by loading and emptying it,
* designed sequences in order to stimulate all the possible code paths * all conditions are tested.
* inside the allocator. The test expects to find the heap back to the
* initial status after each sequence.
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [4.1.1] Testing initial conditions, the heap must not be * - [4.1.1] Adding the objects to the pool using chPoolLoadArray().
* fragmented and one free block present. * - [4.1.2] Emptying the pool using chPoolAlloc().
* - [4.1.2] Trying to allocate an block bigger than available space, * - [4.1.3] Now must be empty.
* an error is expected. * - [4.1.4] Adding the objects to the pool using chPoolFree().
* - [4.1.3] Single block allocation using chHeapAlloc() then the block * - [4.1.5] Emptying the pool using chPoolAlloc() again.
* is freed using chHeapFree(), must not fail. * - [4.1.6] Now must be empty again.
* - [4.1.4] Using chHeapStatus() to assess the heap state. There must * - [4.1.7] Covering the case where a provider is unable to return
* be at least one free block of sufficient size. * more memory.
* - [4.1.5] Allocating then freeing in the same order.
* - [4.1.6] Allocating then freeing in reverse order.
* - [4.1.7] Small fragments handling. Checking the behavior when
* allocating blocks with size not multiple of alignment unit.
* - [4.1.8] Skipping a fragment, the first fragment in the list is too
* small so the allocator must pick the second one.
* - [4.1.9] Allocating the whole available space.
* - [4.1.10] Testing final conditions. The heap geometry must be the
* same than the one registered at beginning.
* . * .
*/ */
static void oslib_test_004_001_setup(void) { static void oslib_test_004_001_setup(void) {
chHeapObjectInit(&test_heap, test_heap_buffer, sizeof(test_heap_buffer)); chPoolObjectInit(&mp1, sizeof (uint32_t), NULL);
} }
static void oslib_test_004_001_execute(void) { static void oslib_test_004_001_execute(void) {
void *p1, *p2, *p3; unsigned i;
size_t n, sz;
/* [4.1.1] Testing initial conditions, the heap must not be /* [4.1.1] Adding the objects to the pool using chPoolLoadArray().*/
fragmented and one free block present.*/
test_set_step(1); test_set_step(1);
{ {
test_assert(chHeapStatus(&test_heap, &sz, NULL) == 1, "heap fragmented"); chPoolLoadArray(&mp1, objects, MEMORY_POOL_SIZE);
} }
/* [4.1.2] Trying to allocate an block bigger than available space, /* [4.1.2] Emptying the pool using chPoolAlloc().*/
an error is expected.*/
test_set_step(2); test_set_step(2);
{ {
p1 = chHeapAlloc(&test_heap, sizeof test_heap_buffer * 2); for (i = 0; i < MEMORY_POOL_SIZE; i++)
test_assert(p1 == NULL, "allocation not failed"); test_assert(chPoolAlloc(&mp1) != NULL, "list empty");
} }
/* [4.1.3] Single block allocation using chHeapAlloc() then the block /* [4.1.3] Now must be empty.*/
is freed using chHeapFree(), must not fail.*/
test_set_step(3); test_set_step(3);
{ {
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE); test_assert(chPoolAlloc(&mp1) == NULL, "list not empty");
test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);
} }
/* [4.1.4] Using chHeapStatus() to assess the heap state. There must /* [4.1.4] Adding the objects to the pool using chPoolFree().*/
be at least one free block of sufficient size.*/
test_set_step(4); test_set_step(4);
{ {
size_t total_size, largest_size; for (i = 0; i < MEMORY_POOL_SIZE; i++)
chPoolFree(&mp1, &objects[i]);
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");
} }
/* [4.1.5] Allocating then freeing in the same order.*/ /* [4.1.5] Emptying the pool using chPoolAlloc() again.*/
test_set_step(5); test_set_step(5);
{ {
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE); for (i = 0; i < MEMORY_POOL_SIZE; i++)
p2 = chHeapAlloc(&test_heap, ALLOC_SIZE); test_assert(chPoolAlloc(&mp1) != NULL, "list empty");
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");
} }
/* [4.1.6] Allocating then freeing in reverse order.*/ /* [4.1.6] Now must be empty again.*/
test_set_step(6); test_set_step(6);
{ {
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE); test_assert(chPoolAlloc(&mp1) == NULL, "list not empty");
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");
} }
/* [4.1.7] Small fragments handling. Checking the behavior when /* [4.1.7] Covering the case where a provider is unable to return
allocating blocks with size not multiple of alignment unit.*/ more memory.*/
test_set_step(7); test_set_step(7);
{ {
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE + 1); chPoolObjectInit(&mp1, sizeof (uint32_t), null_provider);
p2 = chHeapAlloc(&test_heap, ALLOC_SIZE); test_assert(chPoolAlloc(&mp1) == NULL, "provider returned memory");
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");
}
/* [4.1.8] Skipping a fragment, the first fragment in the list is too
small so the allocator must pick the second one.*/
test_set_step(8);
{
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");
}
/* [4.1.9] Allocating the whole available space.*/
test_set_step(9);
{
(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);
}
/* [4.1.10] Testing final conditions. The heap geometry must be the
same than the one registered at beginning.*/
test_set_step(10);
{
test_assert(chHeapStatus(&test_heap, &n, NULL) == 1, "heap fragmented");
test_assert(n == sz, "size changed");
} }
} }
static const testcase_t oslib_test_004_001 = { static const testcase_t oslib_test_004_001 = {
"Allocation and fragmentation", "Loading and emptying a memory pool",
oslib_test_004_001_setup, oslib_test_004_001_setup,
NULL, NULL,
oslib_test_004_001_execute oslib_test_004_001_execute
}; };
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
/** /**
* @page oslib_test_004_002 [4.2] Default Heap * @page oslib_test_004_002 [4.2] Loading and emptying a guarded memory pool without waiting
* *
* <h2>Description</h2> * <h2>Description</h2>
* The default heap is pre-allocated in the system. We test base * The memory pool functionality is tested by loading and emptying it,
* functionality. * all conditions are tested.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_SEMAPHORES
* .
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [4.2.1] Single block allocation using chHeapAlloc() then the block * - [4.2.1] Adding the objects to the pool using
* is freed using chHeapFree(), must not fail. * chGuardedPoolLoadArray().
* - [4.2.2] Testing allocation failure. * - [4.2.2] Emptying the pool using chGuardedPoolAllocTimeout().
* - [4.2.3] Now must be empty.
* - [4.2.4] Adding the objects to the pool using chGuardedPoolFree().
* - [4.2.5] Emptying the pool using chGuardedPoolAllocTimeout() again.
* - [4.2.6] Now must be empty again.
* . * .
*/ */
static void oslib_test_004_002_execute(void) { static void oslib_test_004_002_setup(void) {
void *p1; chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t));
size_t total_size, largest_size; }
/* [4.2.1] Single block allocation using chHeapAlloc() then the block static void oslib_test_004_002_execute(void) {
is freed using chHeapFree(), must not fail.*/ unsigned i;
/* [4.2.1] Adding the objects to the pool using
chGuardedPoolLoadArray().*/
test_set_step(1); test_set_step(1);
{ {
(void)chHeapStatus(NULL, &total_size, &largest_size); chGuardedPoolLoadArray(&gmp1, objects, MEMORY_POOL_SIZE);
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);
} }
/* [4.2.2] Testing allocation failure.*/ /* [4.2.2] Emptying the pool using chGuardedPoolAllocTimeout().*/
test_set_step(2); test_set_step(2);
{ {
p1 = chHeapAlloc(NULL, (size_t)-256); for (i = 0; i < MEMORY_POOL_SIZE; i++)
test_assert(p1 == NULL, "allocation not failed"); test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) != NULL, "list empty");
}
/* [4.2.3] Now must be empty.*/
test_set_step(3);
{
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty");
}
/* [4.2.4] Adding the objects to the pool using
chGuardedPoolFree().*/
test_set_step(4);
{
for (i = 0; i < MEMORY_POOL_SIZE; i++)
chGuardedPoolFree(&gmp1, &objects[i]);
}
/* [4.2.5] Emptying the pool using chGuardedPoolAllocTimeout()
again.*/
test_set_step(5);
{
for (i = 0; i < MEMORY_POOL_SIZE; i++)
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) != NULL, "list empty");
}
/* [4.2.6] Now must be empty again.*/
test_set_step(6);
{
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty");
} }
} }
static const testcase_t oslib_test_004_002 = { static const testcase_t oslib_test_004_002 = {
"Default Heap", "Loading and emptying a guarded memory pool without waiting",
NULL, oslib_test_004_002_setup,
NULL, NULL,
oslib_test_004_002_execute oslib_test_004_002_execute
}; };
#endif /* CH_CFG_USE_SEMAPHORES */
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
/**
* @page oslib_test_004_003 [4.3] Guarded Memory Pools timeout
*
* <h2>Description</h2>
* The timeout features for the Guarded Memory Pools is tested.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_USE_SEMAPHORES
* .
*
* <h2>Test Steps</h2>
* - [4.3.1] Trying to allocate with 100mS timeout, must fail because
* the pool is empty.
* .
*/
static void oslib_test_004_003_setup(void) {
chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t));
}
static void oslib_test_004_003_execute(void) {
/* [4.3.1] Trying to allocate with 100mS timeout, must fail because
the pool is empty.*/
test_set_step(1);
{
test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_MS2I(100)) == NULL, "list not empty");
}
}
static const testcase_t oslib_test_004_003 = {
"Guarded Memory Pools timeout",
oslib_test_004_003_setup,
NULL,
oslib_test_004_003_execute
};
#endif /* CH_CFG_USE_SEMAPHORES */
/**************************************************************************** /****************************************************************************
* Exported data. * Exported data.
@ -265,16 +283,21 @@ static const testcase_t oslib_test_004_002 = {
*/ */
const testcase_t * const oslib_test_sequence_004_array[] = { const testcase_t * const oslib_test_sequence_004_array[] = {
&oslib_test_004_001, &oslib_test_004_001,
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
&oslib_test_004_002, &oslib_test_004_002,
#endif
#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
&oslib_test_004_003,
#endif
NULL NULL
}; };
/** /**
* @brief Memory Heaps. * @brief Memory Pools.
*/ */
const testsequence_t oslib_test_sequence_004 = { const testsequence_t oslib_test_sequence_004 = {
"Memory Heaps", "Memory Pools",
oslib_test_sequence_004_array oslib_test_sequence_004_array
}; };
#endif /* CH_CFG_USE_HEAP */ #endif /* CH_CFG_USE_MEMPOOLS */

789
test/oslib/source/test/oslib_test_sequence_005.c
View File

@ -21,725 +21,240 @@
* @file oslib_test_sequence_005.c * @file oslib_test_sequence_005.c
* @brief Test Sequence 005 code. * @brief Test Sequence 005 code.
* *
* @page oslib_test_sequence_005 [5] Objects Factory * @page oslib_test_sequence_005 [5] Memory Heaps
* *
* File: @ref oslib_test_sequence_005.c * File: @ref oslib_test_sequence_005.c
* *
* <h2>Description</h2> * <h2>Description</h2>
* This sequence tests the ChibiOS library functionalities related to * This sequence tests the ChibiOS library functionalities related to
* the object factory. * memory heaps.
* *
* <h2>Conditions</h2> * <h2>Conditions</h2>
* This sequence is only executed if the following preprocessor condition * This sequence is only executed if the following preprocessor condition
* evaluates to true: * evaluates to true:
* - (CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE) * - CH_CFG_USE_HEAP
* . * .
* *
* <h2>Test Cases</h2> * <h2>Test Cases</h2>
* - @subpage oslib_test_005_001 * - @subpage oslib_test_005_001
* - @subpage oslib_test_005_002 * - @subpage oslib_test_005_002
* - @subpage oslib_test_005_003
* - @subpage oslib_test_005_004
* - @subpage oslib_test_005_005
* - @subpage oslib_test_005_006
* . * .
*/ */
#if ((CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE)) || defined(__DOXYGEN__) #if (CH_CFG_USE_HEAP) || defined(__DOXYGEN__)
/**************************************************************************** /****************************************************************************
* Shared code. * Shared code.
****************************************************************************/ ****************************************************************************/
#define ALLOC_SIZE 16
#define HEAP_SIZE (ALLOC_SIZE * 8)
static memory_heap_t test_heap;
static uint8_t test_heap_buffer[HEAP_SIZE];
/**************************************************************************** /****************************************************************************
* Test cases. * Test cases.
****************************************************************************/ ****************************************************************************/
#if (CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE) || defined(__DOXYGEN__)
/** /**
* @page oslib_test_005_001 [5.1] Objects Registry * @page oslib_test_005_001 [5.1] Allocation and fragmentation
* *
* <h2>Description</h2> * <h2>Description</h2>
* This test case verifies the static objects registry. * Series of allocations/deallocations are performed in carefully
* * designed sequences in order to stimulate all the possible code paths
* <h2>Conditions</h2> * inside the allocator. The test expects to find the heap back to the
* This test is only executed if the following preprocessor condition * initial status after each sequence.
* evaluates to true:
* - CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE
* .
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [5.1.1] Retrieving a registered object by name, must not exist. * - [5.1.1] Testing initial conditions, the heap must not be
* - [5.1.2] Registering an object, it must not exists, must succeed. * fragmented and one free block present.
* - [5.1.3] Registering an object with the same name, must fail. * - [5.1.2] Trying to allocate an block bigger than available space,
* - [5.1.4] Retrieving the registered object by name, must exist, then * an error is expected.
* increasing the reference counter, finally releasing both * - [5.1.3] Single block allocation using chHeapAlloc() then the block
* references. * is freed using chHeapFree(), must not fail.
* - [5.1.5] Releasing the first reference to the object, must not * - [5.1.4] Using chHeapStatus() to assess the heap state. There must
* trigger an assertion. * be at least one free block of sufficient size.
* - [5.1.6] Retrieving the registered object by name again, must not * - [5.1.5] Allocating then freeing in the same order.
* exist. * - [5.1.6] Allocating then freeing in reverse order.
* - [5.1.7] Small fragments handling. Checking the behavior when
* allocating blocks with size not multiple of alignment unit.
* - [5.1.8] Skipping a fragment, the first fragment in the list is too
* small so the allocator must pick the second one.
* - [5.1.9] Allocating the whole available space.
* - [5.1.10] Testing final conditions. The heap geometry must be the
* same than the one registered at beginning.
* . * .
*/ */
static void oslib_test_005_001_teardown(void) { static void oslib_test_005_001_setup(void) {
registered_object_t *rop; chHeapObjectInit(&test_heap, test_heap_buffer, sizeof(test_heap_buffer));
rop = chFactoryFindObject("myobj");
if (rop != NULL) {
while (rop->element.refs > 0U) {
chFactoryReleaseObject(rop);
}
}
} }
static void oslib_test_005_001_execute(void) { static void oslib_test_005_001_execute(void) {
registered_object_t *rop; void *p1, *p2, *p3;
size_t n, sz;
/* [5.1.1] Retrieving a registered object by name, must not exist.*/ /* [5.1.1] Testing initial conditions, the heap must not be
fragmented and one free block present.*/
test_set_step(1); test_set_step(1);
{ {
rop = chFactoryFindObject("myobj"); test_assert(chHeapStatus(&test_heap, &sz, NULL) == 1, "heap fragmented");
test_assert(rop == NULL, "found");
} }
/* [5.1.2] Registering an object, it must not exists, must succeed.*/ /* [5.1.2] Trying to allocate an block bigger than available space,
an error is expected.*/
test_set_step(2); test_set_step(2);
{ {
static uint32_t myobj = 0x55aa; p1 = chHeapAlloc(&test_heap, sizeof test_heap_buffer * 2);
test_assert(p1 == NULL, "allocation not failed");
rop = chFactoryRegisterObject("myobj", (void *)&myobj);
test_assert(rop != NULL, "cannot register");
} }
/* [5.1.3] Registering an object with the same name, must fail.*/ /* [5.1.3] Single block allocation using chHeapAlloc() then the block
is freed using chHeapFree(), must not fail.*/
test_set_step(3); test_set_step(3);
{ {
registered_object_t *rop1; p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
static uint32_t myobj = 0x55aa; test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);
rop1 = chFactoryRegisterObject("myobj", (void *)&myobj);
test_assert(rop1 == NULL, "can register");
} }
/* [5.1.4] Retrieving the registered object by name, must exist, then /* [5.1.4] Using chHeapStatus() to assess the heap state. There must
increasing the reference counter, finally releasing both be at least one free block of sufficient size.*/
references.*/
test_set_step(4); test_set_step(4);
{ {
registered_object_t *rop1, *rop2; size_t total_size, largest_size;
rop1 = chFactoryFindObject("myobj"); n = chHeapStatus(&test_heap, &total_size, &largest_size);
test_assert(rop1 != NULL, "not found"); test_assert(n == 1, "missing free block");
test_assert(*(uint32_t *)(rop1->objp) == 0x55aa, "object mismatch"); test_assert(total_size >= ALLOC_SIZE, "unexpected heap state");
test_assert(rop == rop1, "object reference mismatch"); test_assert(total_size == largest_size, "unexpected heap state");
test_assert(rop1->element.refs == 2, "object reference mismatch");
rop2 = (registered_object_t *)chFactoryDuplicateReference(&rop1->element);
test_assert(rop1 == rop2, "object reference mismatch");
test_assert(*(uint32_t *)(rop2->objp) == 0x55aa, "object mismatch");
test_assert(rop2->element.refs == 3, "object reference mismatch");
chFactoryReleaseObject(rop2);
test_assert(rop1->element.refs == 2, "references mismatch");
chFactoryReleaseObject(rop1);
test_assert(rop->element.refs == 1, "references mismatch");
} }
/* [5.1.5] Releasing the first reference to the object, must not /* [5.1.5] Allocating then freeing in the same order.*/
trigger an assertion.*/
test_set_step(5); test_set_step(5);
{ {
chFactoryReleaseObject(rop); 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");
} }
/* [5.1.6] Retrieving the registered object by name again, must not /* [5.1.6] Allocating then freeing in reverse order.*/
exist.*/
test_set_step(6); test_set_step(6);
{ {
rop = chFactoryFindObject("myobj"); p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
test_assert(rop == NULL, "found"); 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");
}
/* [5.1.7] Small fragments handling. Checking the behavior when
allocating blocks with size not multiple of alignment unit.*/
test_set_step(7);
{
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");
}
/* [5.1.8] Skipping a fragment, the first fragment in the list is too
small so the allocator must pick the second one.*/
test_set_step(8);
{
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");
}
/* [5.1.9] Allocating the whole available space.*/
test_set_step(9);
{
(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);
}
/* [5.1.10] Testing final conditions. The heap geometry must be the
same than the one registered at beginning.*/
test_set_step(10);
{
test_assert(chHeapStatus(&test_heap, &n, NULL) == 1, "heap fragmented");
test_assert(n == sz, "size changed");
} }
} }
static const testcase_t oslib_test_005_001 = { static const testcase_t oslib_test_005_001 = {
"Objects Registry", "Allocation and fragmentation",
oslib_test_005_001_setup,
NULL, NULL,
oslib_test_005_001_teardown,
oslib_test_005_001_execute oslib_test_005_001_execute
}; };
#endif /* CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE */
#if (CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE) || defined(__DOXYGEN__)
/** /**
* @page oslib_test_005_002 [5.2] Dynamic Buffers Factory * @page oslib_test_005_002 [5.2] Default Heap
* *
* <h2>Description</h2> * <h2>Description</h2>
* This test case verifies the dynamic buffers factory. * The default heap is pre-allocated in the system. We test base
* * functionality.
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE
* .
* *
* <h2>Test Steps</h2> * <h2>Test Steps</h2>
* - [5.2.1] Retrieving a dynamic buffer by name, must not exist. * - [5.2.1] Single block allocation using chHeapAlloc() then the block
* - [5.2.2] Creating a dynamic buffer it must not exists, must * is freed using chHeapFree(), must not fail.
* succeed. * - [5.2.2] Testing allocation failure.
* - [5.2.3] Creating a dynamic buffer with the same name, must fail.
* - [5.2.4] Retrieving the dynamic buffer by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [5.2.5] Releasing the first reference to the dynamic buffer, must
* not trigger an assertion.
* - [5.2.6] Retrieving the dynamic buffer by name again, must not
* exist.
* . * .
*/ */
static void oslib_test_005_002_teardown(void) {
dyn_buffer_t *dbp;
dbp = chFactoryFindBuffer("mybuf");
if (dbp != NULL) {
while (dbp->element.refs > 0U) {
chFactoryReleaseBuffer(dbp);
}
}
}
static void oslib_test_005_002_execute(void) { static void oslib_test_005_002_execute(void) {
dyn_buffer_t *dbp; void *p1;
size_t total_size, largest_size;
/* [5.2.1] Retrieving a dynamic buffer by name, must not exist.*/ /* [5.2.1] Single block allocation using chHeapAlloc() then the block
is freed using chHeapFree(), must not fail.*/
test_set_step(1); test_set_step(1);
{ {
dbp = chFactoryFindBuffer("mybuf"); (void)chHeapStatus(NULL, &total_size, &largest_size);
test_assert(dbp == NULL, "found"); p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);
} }
/* [5.2.2] Creating a dynamic buffer it must not exists, must /* [5.2.2] Testing allocation failure.*/
succeed.*/
test_set_step(2); test_set_step(2);
{ {
dbp = chFactoryCreateBuffer("mybuf", 128U); p1 = chHeapAlloc(NULL, (size_t)-256);
test_assert(dbp != NULL, "cannot create"); test_assert(p1 == NULL, "allocation not failed");
}
/* [5.2.3] Creating a dynamic buffer with the same name, must fail.*/
test_set_step(3);
{
dyn_buffer_t *dbp1;
dbp1 = chFactoryCreateBuffer("mybuf", 128U);
test_assert(dbp1 == NULL, "can create");
}
/* [5.2.4] Retrieving the dynamic buffer by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_buffer_t *dbp1, *dbp2;
dbp1 = chFactoryFindBuffer("mybuf");
test_assert(dbp1 != NULL, "not found");
test_assert(dbp == dbp1, "object reference mismatch");
test_assert(dbp1->element.refs == 2, "object reference mismatch");
dbp2 = (dyn_buffer_t *)chFactoryDuplicateReference(&dbp1->element);
test_assert(dbp1 == dbp2, "object reference mismatch");
test_assert(dbp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseBuffer(dbp2);
test_assert(dbp1->element.refs == 2, "references mismatch");
chFactoryReleaseBuffer(dbp1);
test_assert(dbp->element.refs == 1, "references mismatch");
}
/* [5.2.5] Releasing the first reference to the dynamic buffer, must
not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseBuffer(dbp);
}
/* [5.2.6] Retrieving the dynamic buffer by name again, must not
exist.*/
test_set_step(6);
{
dbp = chFactoryFindBuffer("mybuf");
test_assert(dbp == NULL, "found");
} }
} }
static const testcase_t oslib_test_005_002 = { static const testcase_t oslib_test_005_002 = {
"Dynamic Buffers Factory", "Default Heap",
NULL,
NULL, NULL,
oslib_test_005_002_teardown,
oslib_test_005_002_execute oslib_test_005_002_execute
}; };
#endif /* CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE */
#if (CH_CFG_FACTORY_SEMAPHORES == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_005_003 [5.3] Dynamic Semaphores Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic semaphores factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_SEMAPHORES == TRUE
* .
*
* <h2>Test Steps</h2>
* - [5.3.1] Retrieving a dynamic semaphore by name, must not exist.
* - [5.3.2] Creating a dynamic semaphore it must not exists, must
* succeed.
* - [5.3.3] Creating a dynamic semaphore with the same name, must
* fail.
* - [5.3.4] Retrieving the dynamic semaphore by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [5.3.5] Releasing the first reference to the dynamic semaphore
* must not trigger an assertion.
* - [5.3.6] Retrieving the dynamic semaphore by name again, must not
* exist.
* .
*/
static void oslib_test_005_003_teardown(void) {
dyn_semaphore_t *dsp;
dsp = chFactoryFindSemaphore("mysem");
if (dsp != NULL) {
while (dsp->element.refs > 0U) {
chFactoryReleaseSemaphore(dsp);
}
}
}
static void oslib_test_005_003_execute(void) {
dyn_semaphore_t *dsp;
/* [5.3.1] Retrieving a dynamic semaphore by name, must not exist.*/
test_set_step(1);
{
dsp = chFactoryFindSemaphore("mysem");
test_assert(dsp == NULL, "found");
}
/* [5.3.2] Creating a dynamic semaphore it must not exists, must
succeed.*/
test_set_step(2);
{
dsp = chFactoryCreateSemaphore("mysem", 0);
test_assert(dsp != NULL, "cannot create");
}
/* [5.3.3] Creating a dynamic semaphore with the same name, must
fail.*/
test_set_step(3);
{
dyn_semaphore_t *dsp1;
dsp1 = chFactoryCreateSemaphore("mysem", 0);
test_assert(dsp1 == NULL, "can create");
}
/* [5.3.4] Retrieving the dynamic semaphore by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_semaphore_t *dsp1, *dsp2;
dsp1 = chFactoryFindSemaphore("mysem");
test_assert(dsp1 != NULL, "not found");
test_assert(dsp == dsp1, "object reference mismatch");
test_assert(dsp1->element.refs == 2, "object reference mismatch");
dsp2 = (dyn_semaphore_t *)chFactoryDuplicateReference(&dsp1->element);
test_assert(dsp1 == dsp2, "object reference mismatch");
test_assert(dsp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseSemaphore(dsp2);
test_assert(dsp1->element.refs == 2, "references mismatch");
chFactoryReleaseSemaphore(dsp1);
test_assert(dsp->element.refs == 1, "references mismatch");
}
/* [5.3.5] Releasing the first reference to the dynamic semaphore
must not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseSemaphore(dsp);
}
/* [5.3.6] Retrieving the dynamic semaphore by name again, must not
exist.*/
test_set_step(6);
{
dsp = chFactoryFindSemaphore("mysem");
test_assert(dsp == NULL, "found");
}
}
static const testcase_t oslib_test_005_003 = {
"Dynamic Semaphores Factory",
NULL,
oslib_test_005_003_teardown,
oslib_test_005_003_execute
};
#endif /* CH_CFG_FACTORY_SEMAPHORES == TRUE */
#if (CH_CFG_FACTORY_MAILBOXES == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_005_004 [5.4] Dynamic Mailboxes Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic mailboxes factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_MAILBOXES == TRUE
* .
*
* <h2>Test Steps</h2>
* - [5.4.1] Retrieving a dynamic mailbox by name, must not exist.
* - [5.4.2] Creating a dynamic mailbox it must not exists, must
* succeed.
* - [5.4.3] Creating a dynamic mailbox with the same name, must fail.
* - [5.4.4] Retrieving the dynamic mailbox by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [5.4.5] Releasing the first reference to the dynamic mailbox must
* not trigger an assertion.
* - [5.4.6] Retrieving the dynamic mailbox by name again, must not
* exist.
* .
*/
static void oslib_test_005_004_teardown(void) {
dyn_mailbox_t *dmp;
dmp = chFactoryFindMailbox("mymbx");
if (dmp != NULL) {
while (dmp->element.refs > 0U) {
chFactoryReleaseMailbox(dmp);
}
}
}
static void oslib_test_005_004_execute(void) {
dyn_mailbox_t *dmp;
/* [5.4.1] Retrieving a dynamic mailbox by name, must not exist.*/
test_set_step(1);
{
dmp = chFactoryFindMailbox("mymbx");
test_assert(dmp == NULL, "found");
}
/* [5.4.2] Creating a dynamic mailbox it must not exists, must
succeed.*/
test_set_step(2);
{
dmp = chFactoryCreateMailbox("mymbx", 16U);
test_assert(dmp != NULL, "cannot create");
}
/* [5.4.3] Creating a dynamic mailbox with the same name, must
fail.*/
test_set_step(3);
{
dyn_mailbox_t *dmp1;
dmp1 = chFactoryCreateMailbox("mymbx", 16U);
test_assert(dmp1 == NULL, "can create");
}
/* [5.4.4] Retrieving the dynamic mailbox by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_mailbox_t *dmp1, *dmp2;
dmp1 = chFactoryFindMailbox("mymbx");
test_assert(dmp1 != NULL, "not found");
test_assert(dmp == dmp1, "object reference mismatch");
test_assert(dmp1->element.refs == 2, "object reference mismatch");
dmp2 = (dyn_mailbox_t *)chFactoryDuplicateReference(&dmp1->element);
test_assert(dmp1 == dmp2, "object reference mismatch");
test_assert(dmp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseMailbox(dmp2);
test_assert(dmp1->element.refs == 2, "references mismatch");
chFactoryReleaseMailbox(dmp1);
test_assert(dmp->element.refs == 1, "references mismatch");
}
/* [5.4.5] Releasing the first reference to the dynamic mailbox must
not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseMailbox(dmp);
}
/* [5.4.6] Retrieving the dynamic mailbox by name again, must not
exist.*/
test_set_step(6);
{
dmp = chFactoryFindMailbox("mymbx");
test_assert(dmp == NULL, "found");
}
}
static const testcase_t oslib_test_005_004 = {
"Dynamic Mailboxes Factory",
NULL,
oslib_test_005_004_teardown,
oslib_test_005_004_execute
};
#endif /* CH_CFG_FACTORY_MAILBOXES == TRUE */
#if (CH_CFG_FACTORY_OBJ_FIFOS == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_005_005 [5.5] Dynamic Objects FIFOs Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic objects FIFOs factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_OBJ_FIFOS == TRUE
* .
*
* <h2>Test Steps</h2>
* - [5.5.1] Retrieving a dynamic objects FIFO by name, must not exist.
* - [5.5.2] Creating a dynamic objects FIFO it must not exists, must
* succeed.
* - [5.5.3] Creating a dynamic objects FIFO with the same name, must
* fail.
* - [5.5.4] Retrieving the dynamic objects FIFO by name, must exist,
* then increasing the reference counter, finally releasing both
* references.
* - [5.5.5] Releasing the first reference to the dynamic objects FIFO
* must not trigger an assertion.
* - [5.5.6] Retrieving the dynamic objects FIFO by name again, must
* not exist.
* .
*/
static void oslib_test_005_005_teardown(void) {
dyn_objects_fifo_t *dofp;
dofp = chFactoryFindObjectsFIFO("myfifo");
if (dofp != NULL) {
while (dofp->element.refs > 0U) {
chFactoryReleaseObjectsFIFO(dofp);
}
}
}
static void oslib_test_005_005_execute(void) {
dyn_objects_fifo_t *dofp;
/* [5.5.1] Retrieving a dynamic objects FIFO by name, must not
exist.*/
test_set_step(1);
{
dofp = chFactoryFindObjectsFIFO("myfifo");
test_assert(dofp == NULL, "found");
}
/* [5.5.2] Creating a dynamic objects FIFO it must not exists, must
succeed.*/
test_set_step(2);
{
dofp = chFactoryCreateObjectsFIFO("myfifo", 16U, 16U, PORT_NATURAL_ALIGN);
test_assert(dofp != NULL, "cannot create");
}
/* [5.5.3] Creating a dynamic objects FIFO with the same name, must
fail.*/
test_set_step(3);
{
dyn_objects_fifo_t *dofp1;
dofp1 = chFactoryCreateObjectsFIFO("myfifo", 16U, 16U, PORT_NATURAL_ALIGN);
test_assert(dofp1 == NULL, "can create");
}
/* [5.5.4] Retrieving the dynamic objects FIFO by name, must exist,
then increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_objects_fifo_t *dofp1, *dofp2;
dofp1 = chFactoryFindObjectsFIFO("myfifo");
test_assert(dofp1 != NULL, "not found");
test_assert(dofp == dofp1, "object reference mismatch");
test_assert(dofp1->element.refs == 2, "object reference mismatch");
dofp2 = (dyn_objects_fifo_t *)chFactoryDuplicateReference(&dofp1->element);
test_assert(dofp1 == dofp2, "object reference mismatch");
test_assert(dofp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseObjectsFIFO(dofp2);
test_assert(dofp1->element.refs == 2, "references mismatch");
chFactoryReleaseObjectsFIFO(dofp1);
test_assert(dofp->element.refs == 1, "references mismatch");
}
/* [5.5.5] Releasing the first reference to the dynamic objects FIFO
must not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseObjectsFIFO(dofp);
}
/* [5.5.6] Retrieving the dynamic objects FIFO by name again, must
not exist.*/
test_set_step(6);
{
dofp = chFactoryFindObjectsFIFO("myfifo");
test_assert(dofp == NULL, "found");
}
}
static const testcase_t oslib_test_005_005 = {
"Dynamic Objects FIFOs Factory",
NULL,
oslib_test_005_005_teardown,
oslib_test_005_005_execute
};
#endif /* CH_CFG_FACTORY_OBJ_FIFOS == TRUE */
#if (CH_CFG_FACTORY_PIPES == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_005_006 [5.6] Dynamic Pipes Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic pipes factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_PIPES == TRUE
* .
*
* <h2>Test Steps</h2>
* - [5.6.1] Retrieving a dynamic pipe by name, must not exist.
* - [5.6.2] Creating a dynamic pipe it must not exists, must succeed.
* - [5.6.3] Creating a dynamic pipe with the same name, must fail.
* - [5.6.4] Retrieving the dynamic pipe by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [5.6.5] Releasing the first reference to the dynamic pipe must not
* trigger an assertion.
* - [5.6.6] Retrieving the dynamic pipe by name again, must not exist.
* .
*/
static void oslib_test_005_006_teardown(void) {
dyn_pipe_t *dpp;
dpp = chFactoryFindPipe("mypipe");
if (dpp != NULL) {
while (dpp->element.refs > 0U) {
chFactoryReleasePipe(dpp);
}
}
}
static void oslib_test_005_006_execute(void) {
dyn_pipe_t *dpp;
/* [5.6.1] Retrieving a dynamic pipe by name, must not exist.*/
test_set_step(1);
{
dpp = chFactoryFindPipe("mypipe");
test_assert(dpp == NULL, "found");
}
/* [5.6.2] Creating a dynamic pipe it must not exists, must
succeed.*/
test_set_step(2);
{
dpp = chFactoryCreatePipe("mypipe", 16U);
test_assert(dpp != NULL, "cannot create");
}
/* [5.6.3] Creating a dynamic pipe with the same name, must fail.*/
test_set_step(3);
{
dyn_pipe_t *dpp1;
dpp1 = chFactoryCreatePipe("mypipe", 16U);
test_assert(dpp1 == NULL, "can create");
}
/* [5.6.4] Retrieving the dynamic pipe by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_pipe_t *dpp1, *dpp2;
dpp1 = chFactoryFindPipe("mypipe");
test_assert(dpp1 != NULL, "not found");
test_assert(dpp == dpp1, "object reference mismatch");
test_assert(dpp1->element.refs == 2, "object reference mismatch");
dpp2 = (dyn_pipe_t *)chFactoryDuplicateReference(&dpp1->element);
test_assert(dpp1 == dpp2, "object reference mismatch");
test_assert(dpp2->element.refs == 3, "object reference mismatch");
chFactoryReleasePipe(dpp2);
test_assert(dpp1->element.refs == 2, "references mismatch");
chFactoryReleasePipe(dpp1);
test_assert(dpp->element.refs == 1, "references mismatch");
}
/* [5.6.5] Releasing the first reference to the dynamic pipe must not
trigger an assertion.*/
test_set_step(5);
{
chFactoryReleasePipe(dpp);
}
/* [5.6.6] Retrieving the dynamic pipe by name again, must not
exist.*/
test_set_step(6);
{
dpp = chFactoryFindPipe("mypipe");
test_assert(dpp == NULL, "found");
}
}
static const testcase_t oslib_test_005_006 = {
"Dynamic Pipes Factory",
NULL,
oslib_test_005_006_teardown,
oslib_test_005_006_execute
};
#endif /* CH_CFG_FACTORY_PIPES == TRUE */
/**************************************************************************** /****************************************************************************
* Exported data. * Exported data.
@ -749,33 +264,17 @@ static const testcase_t oslib_test_005_006 = {
* @brief Array of test cases. * @brief Array of test cases.
*/ */
const testcase_t * const oslib_test_sequence_005_array[] = { const testcase_t * const oslib_test_sequence_005_array[] = {
#if (CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE) || defined(__DOXYGEN__)
&oslib_test_005_001, &oslib_test_005_001,
#endif
#if (CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE) || defined(__DOXYGEN__)
&oslib_test_005_002, &oslib_test_005_002,
#endif
#if (CH_CFG_FACTORY_SEMAPHORES == TRUE) || defined(__DOXYGEN__)
&oslib_test_005_003,
#endif
#if (CH_CFG_FACTORY_MAILBOXES == TRUE) || defined(__DOXYGEN__)
&oslib_test_005_004,
#endif
#if (CH_CFG_FACTORY_OBJ_FIFOS == TRUE) || defined(__DOXYGEN__)
&oslib_test_005_005,
#endif
#if (CH_CFG_FACTORY_PIPES == TRUE) || defined(__DOXYGEN__)
&oslib_test_005_006,
#endif
NULL NULL
}; };
/** /**
* @brief Objects Factory. * @brief Memory Heaps.
*/ */
const testsequence_t oslib_test_sequence_005 = { const testsequence_t oslib_test_sequence_005 = {
"Objects Factory", "Memory Heaps",
oslib_test_sequence_005_array oslib_test_sequence_005_array
}; };
#endif /* (CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE) */ #endif /* CH_CFG_USE_HEAP */

781
test/oslib/source/test/oslib_test_sequence_006.c Normal file
View File

@ -0,0 +1,781 @@
/*
ChibiOS - Copyright (C) 2006..2017 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.
*/
#include "hal.h"
#include "oslib_test_root.h"
/**
* @file oslib_test_sequence_006.c
* @brief Test Sequence 006 code.
*
* @page oslib_test_sequence_006 [6] Objects Factory
*
* File: @ref oslib_test_sequence_006.c
*
* <h2>Description</h2>
* This sequence tests the ChibiOS library functionalities related to
* the object factory.
*
* <h2>Conditions</h2>
* This sequence is only executed if the following preprocessor condition
* evaluates to true:
* - (CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE)
* .
*
* <h2>Test Cases</h2>
* - @subpage oslib_test_006_001
* - @subpage oslib_test_006_002
* - @subpage oslib_test_006_003
* - @subpage oslib_test_006_004
* - @subpage oslib_test_006_005
* - @subpage oslib_test_006_006
* .
*/
#if ((CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE)) || defined(__DOXYGEN__)
/****************************************************************************
* Shared code.
****************************************************************************/
/****************************************************************************
* Test cases.
****************************************************************************/
#if (CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_006_001 [6.1] Objects Registry
*
* <h2>Description</h2>
* This test case verifies the static objects registry.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE
* .
*
* <h2>Test Steps</h2>
* - [6.1.1] Retrieving a registered object by name, must not exist.
* - [6.1.2] Registering an object, it must not exists, must succeed.
* - [6.1.3] Registering an object with the same name, must fail.
* - [6.1.4] Retrieving the registered object by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [6.1.5] Releasing the first reference to the object, must not
* trigger an assertion.
* - [6.1.6] Retrieving the registered object by name again, must not
* exist.
* .
*/
static void oslib_test_006_001_teardown(void) {
registered_object_t *rop;
rop = chFactoryFindObject("myobj");
if (rop != NULL) {
while (rop->element.refs > 0U) {
chFactoryReleaseObject(rop);
}
}
}
static void oslib_test_006_001_execute(void) {
registered_object_t *rop;
/* [6.1.1] Retrieving a registered object by name, must not exist.*/
test_set_step(1);
{
rop = chFactoryFindObject("myobj");
test_assert(rop == NULL, "found");
}
/* [6.1.2] Registering an object, it must not exists, must succeed.*/
test_set_step(2);
{
static uint32_t myobj = 0x55aa;
rop = chFactoryRegisterObject("myobj", (void *)&myobj);
test_assert(rop != NULL, "cannot register");
}
/* [6.1.3] Registering an object with the same name, must fail.*/
test_set_step(3);
{
registered_object_t *rop1;
static uint32_t myobj = 0x55aa;
rop1 = chFactoryRegisterObject("myobj", (void *)&myobj);
test_assert(rop1 == NULL, "can register");
}
/* [6.1.4] Retrieving the registered object by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
registered_object_t *rop1, *rop2;
rop1 = chFactoryFindObject("myobj");
test_assert(rop1 != NULL, "not found");
test_assert(*(uint32_t *)(rop1->objp) == 0x55aa, "object mismatch");
test_assert(rop == rop1, "object reference mismatch");
test_assert(rop1->element.refs == 2, "object reference mismatch");
rop2 = (registered_object_t *)chFactoryDuplicateReference(&rop1->element);
test_assert(rop1 == rop2, "object reference mismatch");
test_assert(*(uint32_t *)(rop2->objp) == 0x55aa, "object mismatch");
test_assert(rop2->element.refs == 3, "object reference mismatch");
chFactoryReleaseObject(rop2);
test_assert(rop1->element.refs == 2, "references mismatch");
chFactoryReleaseObject(rop1);
test_assert(rop->element.refs == 1, "references mismatch");
}
/* [6.1.5] Releasing the first reference to the object, must not
trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseObject(rop);
}
/* [6.1.6] Retrieving the registered object by name again, must not
exist.*/
test_set_step(6);
{
rop = chFactoryFindObject("myobj");
test_assert(rop == NULL, "found");
}
}
static const testcase_t oslib_test_006_001 = {
"Objects Registry",
NULL,
oslib_test_006_001_teardown,
oslib_test_006_001_execute
};
#endif /* CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE */
#if (CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_006_002 [6.2] Dynamic Buffers Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic buffers factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE
* .
*
* <h2>Test Steps</h2>
* - [6.2.1] Retrieving a dynamic buffer by name, must not exist.
* - [6.2.2] Creating a dynamic buffer it must not exists, must
* succeed.
* - [6.2.3] Creating a dynamic buffer with the same name, must fail.
* - [6.2.4] Retrieving the dynamic buffer by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [6.2.5] Releasing the first reference to the dynamic buffer, must
* not trigger an assertion.
* - [6.2.6] Retrieving the dynamic buffer by name again, must not
* exist.
* .
*/
static void oslib_test_006_002_teardown(void) {
dyn_buffer_t *dbp;
dbp = chFactoryFindBuffer("mybuf");
if (dbp != NULL) {
while (dbp->element.refs > 0U) {
chFactoryReleaseBuffer(dbp);
}
}
}
static void oslib_test_006_002_execute(void) {
dyn_buffer_t *dbp;
/* [6.2.1] Retrieving a dynamic buffer by name, must not exist.*/
test_set_step(1);
{
dbp = chFactoryFindBuffer("mybuf");
test_assert(dbp == NULL, "found");
}
/* [6.2.2] Creating a dynamic buffer it must not exists, must
succeed.*/
test_set_step(2);
{
dbp = chFactoryCreateBuffer("mybuf", 128U);
test_assert(dbp != NULL, "cannot create");
}
/* [6.2.3] Creating a dynamic buffer with the same name, must fail.*/
test_set_step(3);
{
dyn_buffer_t *dbp1;
dbp1 = chFactoryCreateBuffer("mybuf", 128U);
test_assert(dbp1 == NULL, "can create");
}
/* [6.2.4] Retrieving the dynamic buffer by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_buffer_t *dbp1, *dbp2;
dbp1 = chFactoryFindBuffer("mybuf");
test_assert(dbp1 != NULL, "not found");
test_assert(dbp == dbp1, "object reference mismatch");
test_assert(dbp1->element.refs == 2, "object reference mismatch");
dbp2 = (dyn_buffer_t *)chFactoryDuplicateReference(&dbp1->element);
test_assert(dbp1 == dbp2, "object reference mismatch");
test_assert(dbp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseBuffer(dbp2);
test_assert(dbp1->element.refs == 2, "references mismatch");
chFactoryReleaseBuffer(dbp1);
test_assert(dbp->element.refs == 1, "references mismatch");
}
/* [6.2.5] Releasing the first reference to the dynamic buffer, must
not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseBuffer(dbp);
}
/* [6.2.6] Retrieving the dynamic buffer by name again, must not
exist.*/
test_set_step(6);
{
dbp = chFactoryFindBuffer("mybuf");
test_assert(dbp == NULL, "found");
}
}
static const testcase_t oslib_test_006_002 = {
"Dynamic Buffers Factory",
NULL,
oslib_test_006_002_teardown,
oslib_test_006_002_execute
};
#endif /* CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE */
#if (CH_CFG_FACTORY_SEMAPHORES == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_006_003 [6.3] Dynamic Semaphores Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic semaphores factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_SEMAPHORES == TRUE
* .
*
* <h2>Test Steps</h2>
* - [6.3.1] Retrieving a dynamic semaphore by name, must not exist.
* - [6.3.2] Creating a dynamic semaphore it must not exists, must
* succeed.
* - [6.3.3] Creating a dynamic semaphore with the same name, must
* fail.
* - [6.3.4] Retrieving the dynamic semaphore by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [6.3.5] Releasing the first reference to the dynamic semaphore
* must not trigger an assertion.
* - [6.3.6] Retrieving the dynamic semaphore by name again, must not
* exist.
* .
*/
static void oslib_test_006_003_teardown(void) {
dyn_semaphore_t *dsp;
dsp = chFactoryFindSemaphore("mysem");
if (dsp != NULL) {
while (dsp->element.refs > 0U) {
chFactoryReleaseSemaphore(dsp);
}
}
}
static void oslib_test_006_003_execute(void) {
dyn_semaphore_t *dsp;
/* [6.3.1] Retrieving a dynamic semaphore by name, must not exist.*/
test_set_step(1);
{
dsp = chFactoryFindSemaphore("mysem");
test_assert(dsp == NULL, "found");
}
/* [6.3.2] Creating a dynamic semaphore it must not exists, must
succeed.*/
test_set_step(2);
{
dsp = chFactoryCreateSemaphore("mysem", 0);
test_assert(dsp != NULL, "cannot create");
}
/* [6.3.3] Creating a dynamic semaphore with the same name, must
fail.*/
test_set_step(3);
{
dyn_semaphore_t *dsp1;
dsp1 = chFactoryCreateSemaphore("mysem", 0);
test_assert(dsp1 == NULL, "can create");
}
/* [6.3.4] Retrieving the dynamic semaphore by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_semaphore_t *dsp1, *dsp2;
dsp1 = chFactoryFindSemaphore("mysem");
test_assert(dsp1 != NULL, "not found");
test_assert(dsp == dsp1, "object reference mismatch");
test_assert(dsp1->element.refs == 2, "object reference mismatch");
dsp2 = (dyn_semaphore_t *)chFactoryDuplicateReference(&dsp1->element);
test_assert(dsp1 == dsp2, "object reference mismatch");
test_assert(dsp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseSemaphore(dsp2);
test_assert(dsp1->element.refs == 2, "references mismatch");
chFactoryReleaseSemaphore(dsp1);
test_assert(dsp->element.refs == 1, "references mismatch");
}
/* [6.3.5] Releasing the first reference to the dynamic semaphore
must not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseSemaphore(dsp);
}
/* [6.3.6] Retrieving the dynamic semaphore by name again, must not
exist.*/
test_set_step(6);
{
dsp = chFactoryFindSemaphore("mysem");
test_assert(dsp == NULL, "found");
}
}
static const testcase_t oslib_test_006_003 = {
"Dynamic Semaphores Factory",
NULL,
oslib_test_006_003_teardown,
oslib_test_006_003_execute
};
#endif /* CH_CFG_FACTORY_SEMAPHORES == TRUE */
#if (CH_CFG_FACTORY_MAILBOXES == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_006_004 [6.4] Dynamic Mailboxes Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic mailboxes factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_MAILBOXES == TRUE
* .
*
* <h2>Test Steps</h2>
* - [6.4.1] Retrieving a dynamic mailbox by name, must not exist.
* - [6.4.2] Creating a dynamic mailbox it must not exists, must
* succeed.
* - [6.4.3] Creating a dynamic mailbox with the same name, must fail.
* - [6.4.4] Retrieving the dynamic mailbox by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [6.4.5] Releasing the first reference to the dynamic mailbox must
* not trigger an assertion.
* - [6.4.6] Retrieving the dynamic mailbox by name again, must not
* exist.
* .
*/
static void oslib_test_006_004_teardown(void) {
dyn_mailbox_t *dmp;
dmp = chFactoryFindMailbox("mymbx");
if (dmp != NULL) {
while (dmp->element.refs > 0U) {
chFactoryReleaseMailbox(dmp);
}
}
}
static void oslib_test_006_004_execute(void) {
dyn_mailbox_t *dmp;
/* [6.4.1] Retrieving a dynamic mailbox by name, must not exist.*/
test_set_step(1);
{
dmp = chFactoryFindMailbox("mymbx");
test_assert(dmp == NULL, "found");
}
/* [6.4.2] Creating a dynamic mailbox it must not exists, must
succeed.*/
test_set_step(2);
{
dmp = chFactoryCreateMailbox("mymbx", 16U);
test_assert(dmp != NULL, "cannot create");
}
/* [6.4.3] Creating a dynamic mailbox with the same name, must
fail.*/
test_set_step(3);
{
dyn_mailbox_t *dmp1;
dmp1 = chFactoryCreateMailbox("mymbx", 16U);
test_assert(dmp1 == NULL, "can create");
}
/* [6.4.4] Retrieving the dynamic mailbox by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_mailbox_t *dmp1, *dmp2;
dmp1 = chFactoryFindMailbox("mymbx");
test_assert(dmp1 != NULL, "not found");
test_assert(dmp == dmp1, "object reference mismatch");
test_assert(dmp1->element.refs == 2, "object reference mismatch");
dmp2 = (dyn_mailbox_t *)chFactoryDuplicateReference(&dmp1->element);
test_assert(dmp1 == dmp2, "object reference mismatch");
test_assert(dmp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseMailbox(dmp2);
test_assert(dmp1->element.refs == 2, "references mismatch");
chFactoryReleaseMailbox(dmp1);
test_assert(dmp->element.refs == 1, "references mismatch");
}
/* [6.4.5] Releasing the first reference to the dynamic mailbox must
not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseMailbox(dmp);
}
/* [6.4.6] Retrieving the dynamic mailbox by name again, must not
exist.*/
test_set_step(6);
{
dmp = chFactoryFindMailbox("mymbx");
test_assert(dmp == NULL, "found");
}
}
static const testcase_t oslib_test_006_004 = {
"Dynamic Mailboxes Factory",
NULL,
oslib_test_006_004_teardown,
oslib_test_006_004_execute
};
#endif /* CH_CFG_FACTORY_MAILBOXES == TRUE */
#if (CH_CFG_FACTORY_OBJ_FIFOS == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_006_005 [6.5] Dynamic Objects FIFOs Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic objects FIFOs factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_OBJ_FIFOS == TRUE
* .
*
* <h2>Test Steps</h2>
* - [6.5.1] Retrieving a dynamic objects FIFO by name, must not exist.
* - [6.5.2] Creating a dynamic objects FIFO it must not exists, must
* succeed.
* - [6.5.3] Creating a dynamic objects FIFO with the same name, must
* fail.
* - [6.5.4] Retrieving the dynamic objects FIFO by name, must exist,
* then increasing the reference counter, finally releasing both
* references.
* - [6.5.5] Releasing the first reference to the dynamic objects FIFO
* must not trigger an assertion.
* - [6.5.6] Retrieving the dynamic objects FIFO by name again, must
* not exist.
* .
*/
static void oslib_test_006_005_teardown(void) {
dyn_objects_fifo_t *dofp;
dofp = chFactoryFindObjectsFIFO("myfifo");
if (dofp != NULL) {
while (dofp->element.refs > 0U) {
chFactoryReleaseObjectsFIFO(dofp);
}
}
}
static void oslib_test_006_005_execute(void) {
dyn_objects_fifo_t *dofp;
/* [6.5.1] Retrieving a dynamic objects FIFO by name, must not
exist.*/
test_set_step(1);
{
dofp = chFactoryFindObjectsFIFO("myfifo");
test_assert(dofp == NULL, "found");
}
/* [6.5.2] Creating a dynamic objects FIFO it must not exists, must
succeed.*/
test_set_step(2);
{
dofp = chFactoryCreateObjectsFIFO("myfifo", 16U, 16U, PORT_NATURAL_ALIGN);
test_assert(dofp != NULL, "cannot create");
}
/* [6.5.3] Creating a dynamic objects FIFO with the same name, must
fail.*/
test_set_step(3);
{
dyn_objects_fifo_t *dofp1;
dofp1 = chFactoryCreateObjectsFIFO("myfifo", 16U, 16U, PORT_NATURAL_ALIGN);
test_assert(dofp1 == NULL, "can create");
}
/* [6.5.4] Retrieving the dynamic objects FIFO by name, must exist,
then increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_objects_fifo_t *dofp1, *dofp2;
dofp1 = chFactoryFindObjectsFIFO("myfifo");
test_assert(dofp1 != NULL, "not found");
test_assert(dofp == dofp1, "object reference mismatch");
test_assert(dofp1->element.refs == 2, "object reference mismatch");
dofp2 = (dyn_objects_fifo_t *)chFactoryDuplicateReference(&dofp1->element);
test_assert(dofp1 == dofp2, "object reference mismatch");
test_assert(dofp2->element.refs == 3, "object reference mismatch");
chFactoryReleaseObjectsFIFO(dofp2);
test_assert(dofp1->element.refs == 2, "references mismatch");
chFactoryReleaseObjectsFIFO(dofp1);
test_assert(dofp->element.refs == 1, "references mismatch");
}
/* [6.5.5] Releasing the first reference to the dynamic objects FIFO
must not trigger an assertion.*/
test_set_step(5);
{
chFactoryReleaseObjectsFIFO(dofp);
}
/* [6.5.6] Retrieving the dynamic objects FIFO by name again, must
not exist.*/
test_set_step(6);
{
dofp = chFactoryFindObjectsFIFO("myfifo");
test_assert(dofp == NULL, "found");
}
}
static const testcase_t oslib_test_006_005 = {
"Dynamic Objects FIFOs Factory",
NULL,
oslib_test_006_005_teardown,
oslib_test_006_005_execute
};
#endif /* CH_CFG_FACTORY_OBJ_FIFOS == TRUE */
#if (CH_CFG_FACTORY_PIPES == TRUE) || defined(__DOXYGEN__)
/**
* @page oslib_test_006_006 [6.6] Dynamic Pipes Factory
*
* <h2>Description</h2>
* This test case verifies the dynamic pipes factory.
*
* <h2>Conditions</h2>
* This test is only executed if the following preprocessor condition
* evaluates to true:
* - CH_CFG_FACTORY_PIPES == TRUE
* .
*
* <h2>Test Steps</h2>
* - [6.6.1] Retrieving a dynamic pipe by name, must not exist.
* - [6.6.2] Creating a dynamic pipe it must not exists, must succeed.
* - [6.6.3] Creating a dynamic pipe with the same name, must fail.
* - [6.6.4] Retrieving the dynamic pipe by name, must exist, then
* increasing the reference counter, finally releasing both
* references.
* - [6.6.5] Releasing the first reference to the dynamic pipe must not
* trigger an assertion.
* - [6.6.6] Retrieving the dynamic pipe by name again, must not exist.
* .
*/
static void oslib_test_006_006_teardown(void) {
dyn_pipe_t *dpp;
dpp = chFactoryFindPipe("mypipe");
if (dpp != NULL) {
while (dpp->element.refs > 0U) {
chFactoryReleasePipe(dpp);
}
}
}
static void oslib_test_006_006_execute(void) {
dyn_pipe_t *dpp;
/* [6.6.1] Retrieving a dynamic pipe by name, must not exist.*/
test_set_step(1);
{
dpp = chFactoryFindPipe("mypipe");
test_assert(dpp == NULL, "found");
}
/* [6.6.2] Creating a dynamic pipe it must not exists, must
succeed.*/
test_set_step(2);
{
dpp = chFactoryCreatePipe("mypipe", 16U);
test_assert(dpp != NULL, "cannot create");
}
/* [6.6.3] Creating a dynamic pipe with the same name, must fail.*/
test_set_step(3);
{
dyn_pipe_t *dpp1;
dpp1 = chFactoryCreatePipe("mypipe", 16U);
test_assert(dpp1 == NULL, "can create");
}
/* [6.6.4] Retrieving the dynamic pipe by name, must exist, then
increasing the reference counter, finally releasing both
references.*/
test_set_step(4);
{
dyn_pipe_t *dpp1, *dpp2;
dpp1 = chFactoryFindPipe("mypipe");
test_assert(dpp1 != NULL, "not found");
test_assert(dpp == dpp1, "object reference mismatch");
test_assert(dpp1->element.refs == 2, "object reference mismatch");
dpp2 = (dyn_pipe_t *)chFactoryDuplicateReference(&dpp1->element);
test_assert(dpp1 == dpp2, "object reference mismatch");
test_assert(dpp2->element.refs == 3, "object reference mismatch");
chFactoryReleasePipe(dpp2);
test_assert(dpp1->element.refs == 2, "references mismatch");
chFactoryReleasePipe(dpp1);
test_assert(dpp->element.refs == 1, "references mismatch");
}
/* [6.6.5] Releasing the first reference to the dynamic pipe must not
trigger an assertion.*/
test_set_step(5);
{
chFactoryReleasePipe(dpp);
}
/* [6.6.6] Retrieving the dynamic pipe by name again, must not
exist.*/
test_set_step(6);
{
dpp = chFactoryFindPipe("mypipe");
test_assert(dpp == NULL, "found");
}
}
static const testcase_t oslib_test_006_006 = {
"Dynamic Pipes Factory",
NULL,
oslib_test_006_006_teardown,
oslib_test_006_006_execute
};
#endif /* CH_CFG_FACTORY_PIPES == TRUE */
/****************************************************************************
* Exported data.
****************************************************************************/
/**
* @brief Array of test cases.
*/
const testcase_t * const oslib_test_sequence_006_array[] = {
#if (CH_CFG_FACTORY_OBJECTS_REGISTRY == TRUE) || defined(__DOXYGEN__)
&oslib_test_006_001,
#endif
#if (CH_CFG_FACTORY_GENERIC_BUFFERS == TRUE) || defined(__DOXYGEN__)
&oslib_test_006_002,
#endif
#if (CH_CFG_FACTORY_SEMAPHORES == TRUE) || defined(__DOXYGEN__)
&oslib_test_006_003,
#endif
#if (CH_CFG_FACTORY_MAILBOXES == TRUE) || defined(__DOXYGEN__)
&oslib_test_006_004,
#endif
#if (CH_CFG_FACTORY_OBJ_FIFOS == TRUE) || defined(__DOXYGEN__)
&oslib_test_006_005,
#endif
#if (CH_CFG_FACTORY_PIPES == TRUE) || defined(__DOXYGEN__)
&oslib_test_006_006,
#endif
NULL
};
/**
* @brief Objects Factory.
*/
const testsequence_t oslib_test_sequence_006 = {
"Objects Factory",
oslib_test_sequence_006_array
};
#endif /* (CH_CFG_USE_FACTORY == TRUE) && (CH_CFG_USE_MEMPOOLS == TRUE) && (CH_CFG_USE_HEAP == TRUE) */

27
test/oslib/source/test/oslib_test_sequence_006.h Normal file
View File

@ -0,0 +1,27 @@
/*
ChibiOS - Copyright (C) 2006..2017 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.
*/
/**
* @file oslib_test_sequence_006.h
* @brief Test Sequence 006 header.
*/
#ifndef OSLIB_TEST_SEQUENCE_006_H
#define OSLIB_TEST_SEQUENCE_006_H
extern const testsequence_t oslib_test_sequence_006;
#endif /* OSLIB_TEST_SEQUENCE_006_H */

36
test/rt/configuration.xml
View File

@ -358,46 +358,10 @@ test_printn(CH_CFG_USE_MESSAGES);
test_println(""); test_println("");
test_print("--- CH_CFG_USE_MESSAGES_PRIORITY: "); test_print("--- CH_CFG_USE_MESSAGES_PRIORITY: ");
test_printn(CH_CFG_USE_MESSAGES_PRIORITY); test_printn(CH_CFG_USE_MESSAGES_PRIORITY);
test_println("");
test_print("--- CH_CFG_USE_MAILBOXES: ");
test_printn(CH_CFG_USE_MAILBOXES);
test_println("");
test_print("--- CH_CFG_USE_MEMCORE: ");
test_printn(CH_CFG_USE_MEMCORE);
test_println("");
test_print("--- CH_CFG_USE_HEAP: ");
test_printn(CH_CFG_USE_HEAP);
test_println("");
test_print("--- CH_CFG_USE_MEMPOOLS: ");
test_printn(CH_CFG_USE_MEMPOOLS);
test_println("");
test_print("--- CH_CFG_USE_OBJ_FIFOS: ");
test_printn(CH_CFG_USE_OBJ_FIFOS);
test_println(""); test_println("");
test_print("--- CH_CFG_USE_DYNAMIC: "); test_print("--- CH_CFG_USE_DYNAMIC: ");
test_printn(CH_CFG_USE_DYNAMIC); test_printn(CH_CFG_USE_DYNAMIC);
test_println(""); test_println("");
test_print("--- CH_CFG_USE_FACTORY: ");
test_printn(CH_CFG_USE_FACTORY);
test_println("");
test_print("--- CH_CFG_FACTORY_MAX_NAMES_LENGTH: ");
test_printn(CH_CFG_FACTORY_MAX_NAMES_LENGTH);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJECTS_REGISTRY: ");
test_printn(CH_CFG_FACTORY_OBJECTS_REGISTRY);
test_println("");
test_print("--- CH_CFG_FACTORY_GENERIC_BUFFERS: ");
test_printn(CH_CFG_FACTORY_GENERIC_BUFFERS);
test_println("");
test_print("--- CH_CFG_FACTORY_SEMAPHORES: ");
test_printn(CH_CFG_FACTORY_SEMAPHORES);
test_println("");
test_print("--- CH_CFG_FACTORY_MAILBOXES: ");
test_printn(CH_CFG_FACTORY_MAILBOXES);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJ_FIFOS: ");
test_printn(CH_CFG_FACTORY_OBJ_FIFOS);
test_println("");
test_print("--- CH_DBG_STATISTICS: "); test_print("--- CH_DBG_STATISTICS: ");
test_printn(CH_DBG_STATISTICS); test_printn(CH_DBG_STATISTICS);
test_println(""); test_println("");

36
test/rt/source/test/rt_test_sequence_001.c
View File

@ -226,45 +226,9 @@ static void rt_test_001_003_execute(void) {
test_print("--- CH_CFG_USE_MESSAGES_PRIORITY: "); test_print("--- CH_CFG_USE_MESSAGES_PRIORITY: ");
test_printn(CH_CFG_USE_MESSAGES_PRIORITY); test_printn(CH_CFG_USE_MESSAGES_PRIORITY);
test_println(""); test_println("");
test_print("--- CH_CFG_USE_MAILBOXES: ");
test_printn(CH_CFG_USE_MAILBOXES);
test_println("");
test_print("--- CH_CFG_USE_MEMCORE: ");
test_printn(CH_CFG_USE_MEMCORE);
test_println("");
test_print("--- CH_CFG_USE_HEAP: ");
test_printn(CH_CFG_USE_HEAP);
test_println("");
test_print("--- CH_CFG_USE_MEMPOOLS: ");
test_printn(CH_CFG_USE_MEMPOOLS);
test_println("");
test_print("--- CH_CFG_USE_OBJ_FIFOS: ");
test_printn(CH_CFG_USE_OBJ_FIFOS);
test_println("");
test_print("--- CH_CFG_USE_DYNAMIC: "); test_print("--- CH_CFG_USE_DYNAMIC: ");
test_printn(CH_CFG_USE_DYNAMIC); test_printn(CH_CFG_USE_DYNAMIC);
test_println(""); test_println("");
test_print("--- CH_CFG_USE_FACTORY: ");
test_printn(CH_CFG_USE_FACTORY);
test_println("");
test_print("--- CH_CFG_FACTORY_MAX_NAMES_LENGTH: ");
test_printn(CH_CFG_FACTORY_MAX_NAMES_LENGTH);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJECTS_REGISTRY: ");
test_printn(CH_CFG_FACTORY_OBJECTS_REGISTRY);
test_println("");
test_print("--- CH_CFG_FACTORY_GENERIC_BUFFERS: ");
test_printn(CH_CFG_FACTORY_GENERIC_BUFFERS);
test_println("");
test_print("--- CH_CFG_FACTORY_SEMAPHORES: ");
test_printn(CH_CFG_FACTORY_SEMAPHORES);
test_println("");
test_print("--- CH_CFG_FACTORY_MAILBOXES: ");
test_printn(CH_CFG_FACTORY_MAILBOXES);
test_println("");
test_print("--- CH_CFG_FACTORY_OBJ_FIFOS: ");
test_printn(CH_CFG_FACTORY_OBJ_FIFOS);
test_println("");
test_print("--- CH_DBG_STATISTICS: "); test_print("--- CH_DBG_STATISTICS: ");
test_printn(CH_DBG_STATISTICS); test_printn(CH_DBG_STATISTICS);
test_println(""); test_println("");