Fixed bugs #1060 and bug #1061.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@13192 27425a3e-05d8-49a3-a47f-9c15f0e5edd8

os/hal/lib/fallback/I2C/hal_i2c_lld.c

@@ -94,7 +94,7 @@ static inline msg_t i2c_check_arbitration(I2CDriver *i2cp) {
 
 static inline msg_t i2c_check_timeout(I2CDriver *i2cp) {
 
-  if (!osalOsIsTimeWithinX(osalOsGetSystemTimeX(), i2cp->start, i2cp->end)) {
+  if (!osalTimeIsInRangeX(osalOsGetSystemTimeX(), i2cp->start, i2cp->end)) {
     i2c_write_stop(i2cp);
     return MSG_TIMEOUT;
   }
@@ -105,7 +105,7 @@ static inline msg_t i2c_check_timeout(I2CDriver *i2cp) {
 static msg_t i2c_wait_clock(I2CDriver *i2cp) {
 
   while (palReadLine(i2cp->config->scl) == PAL_LOW) {
-    if (!osalOsIsTimeWithinX(osalOsGetSystemTimeX(), i2cp->start, i2cp->end)) {
+    if (!osalTimeIsInRangeX(osalOsGetSystemTimeX(), i2cp->start, i2cp->end)) {
       return MSG_TIMEOUT;
     }
     i2c_delay(i2cp);
@@ -347,18 +347,18 @@ void i2c_lld_stop(I2CDriver *i2cp) {
  */
 msg_t i2c_lld_master_receive_timeout(I2CDriver *i2cp, i2caddr_t addr,
                                      uint8_t *rxbuf, size_t rxbytes,
-                                     systime_t timeout) {
+                                     sysinterval_t timeout) {
 
   /* Setting timeout fields.*/
   i2cp->start = osalOsGetSystemTimeX();
   i2cp->end = i2cp->start;
   if (timeout != TIME_INFINITE) {
-    i2cp->end += timeout;
+    i2cp->end = osalTimeAddX(i2cp->start, timeout);
   }
 
   CHECK_ERROR(i2c_write_start(i2cp));
 
-  /* Sending anddress and mode.*/
+  /* Sending address and mode.*/
   CHECK_ERROR(i2c_write_header(i2cp, addr, true));
 
   do {
@@ -399,19 +399,19 @@ msg_t i2c_lld_master_receive_timeout(I2CDriver *i2cp, i2caddr_t addr,
 msg_t i2c_lld_master_transmit_timeout(I2CDriver *i2cp, i2caddr_t addr,
                                       const uint8_t *txbuf, size_t txbytes,
                                       uint8_t *rxbuf, size_t rxbytes,
-                                      systime_t timeout) {
+                                      sysinterval_t timeout) {
 
   /* Setting timeout fields.*/
   i2cp->start = osalOsGetSystemTimeX();
   i2cp->end = i2cp->start;
   if (timeout != TIME_INFINITE) {
-    i2cp->end += timeout;
+    i2cp->end = osalTimeAddX(i2cp->start, timeout);
   }
 
   /* send start condition */  
   CHECK_ERROR(i2c_write_start(i2cp));
 
-  /* Sending anddress and mode.*/
+  /* Sending address and mode.*/
   CHECK_ERROR(i2c_write_header(i2cp, addr, false));
 
   do {

os/hal/lib/fallback/I2C/hal_i2c_lld.h

@@ -217,10 +217,10 @@ extern "C" {
   msg_t i2c_lld_master_transmit_timeout(I2CDriver *i2cp, i2caddr_t addr,
                                         const uint8_t *txbuf, size_t txbytes,
                                         uint8_t *rxbuf, size_t rxbytes,
-                                        systime_t timeout);
+                                        sysinterval_t timeout);
   msg_t i2c_lld_master_receive_timeout(I2CDriver *i2cp, i2caddr_t addr,
                                        uint8_t *rxbuf, size_t rxbytes,
-                                       systime_t timeout);
+                                       sysinterval_t timeout);
 #ifdef __cplusplus
 }
 #endif

os/hal/osal/os-less/ARMCMx/osal.h

@@ -703,7 +703,8 @@ static inline bool osalTimeIsInRangeX(systime_t time,
                                       systime_t start,
                                       systime_t end) {
 
-  return (bool)((time - start) < (end - start));
+  return (bool)((systime_t)((systime_t)time - (systime_t)start) <=
+                (systime_t)((systime_t)end - (systime_t)start - (systime_t)1));
 }
 
 /**

os/hal/templates/osal/osal.h

@@ -639,7 +639,8 @@ static inline bool osalTimeIsInRangeX(systime_t time,
                                       systime_t start,
                                       systime_t end) {
 
-  return (bool)((time - start) < (end - start));
+  return (bool)((systime_t)((systime_t)time - (systime_t)start) <=
+                (systime_t)((systime_t)end - (systime_t)start - (systime_t)1));
 }
 
 /**

os/nil/include/ch.h

@@ -1278,23 +1278,6 @@ struct nil_system {
 #define chTimeDiffX(start, end)                                             \
   ((sysinterval_t)((systime_t)((systime_t)(end) - (systime_t)(start))))
 
-/**
- * @brief   Checks if the specified time is within the specified time range.
- * @note    When start==end then the function returns always true because the
- *          whole time range is specified.
- *
- * @param[in] time      the time to be verified
- * @param[in] start     the start of the time window (inclusive)
- * @param[in] end       the end of the time window (non inclusive)
- * @retval true         current time within the specified time window.
- * @retval false        current time not within the specified time window.
- *
- * @xclass
- */
-#define chTimeIsInRangeX(time, start, end)                                  \
-  ((bool)((systime_t)((systime_t)(time) - (systime_t)(start)) <             \
-          (systime_t)((systime_t)(end) - (systime_t)(start))))
-
 /**
  * @brief   Function parameters check.
  * @details If the condition check fails then the kernel panics and halts.
@@ -1392,6 +1375,7 @@ extern "C" {
   void chSchDoReschedule(void);
   void chSchRescheduleS(void);
   msg_t chSchGoSleepTimeoutS(tstate_t newstate, sysinterval_t timeout);
+  bool chTimeIsInRangeX(systime_t time, systime_t start, systime_t end);
   thread_t *chThdCreateI(const thread_descriptor_t *tdp);
   thread_t *chThdCreate(const thread_descriptor_t *tdp);
   void chThdExit(msg_t msg);

os/nil/src/ch.c

@@ -722,6 +722,25 @@ msg_t chSchGoSleepTimeoutS(tstate_t newstate, sysinterval_t timeout) {
   }
 }
 
+/**
+ * @brief   Checks if the specified time is within the specified time range.
+ * @note    When start==end then the function returns always true because the
+ *          whole time range is specified.
+ *
+ * @param[in] time      the time to be verified
+ * @param[in] start     the start of the time window (inclusive)
+ * @param[in] end       the end of the time window (non inclusive)
+ * @retval true         current time within the specified time window.
+ * @retval false        current time not within the specified time window.
+ *
+ * @xclass
+ */
+bool chTimeIsInRangeX(systime_t time, systime_t start, systime_t end) {
+
+  return (bool)((systime_t)((systime_t)(time) - (systime_t)(start)) <=
+      (systime_t)((systime_t)(end) - (systime_t)(start) - (systime_t)1));
+}
+
 /**
  * @brief   Creates a new thread into a static memory area.
  * @details The new thread is initialized and make ready to execute.

os/rt/include/chtime.h

@@ -481,8 +481,8 @@ static inline bool chTimeIsInRangeX(systime_t time,
                                     systime_t start,
                                     systime_t end) {
 
-  return (bool)((systime_t)((systime_t)time - (systime_t)start) <
+  return (bool)((systime_t)((systime_t)time - (systime_t)start) <=
-                (systime_t)((systime_t)end - (systime_t)start));
+                (systime_t)((systime_t)end - (systime_t)start - (systime_t)1));
 }
 
 /** @} */

readme.txt

@@ -140,6 +140,10 @@
 - 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).
 - NIL: Integrated NIL 4.0.
+- FIX: Fixed I2C fallback driver broken (bug #1061)
+       (not yet)(backported to 19.1.4)(backported to 18.2.3).
+- FIX: Fixed bug in chVTGetSystemTimeX() (bug #1060)
+       (not yet)(backported to 19.1.4)(backported to 18.2.3).
 - FIX: Fixed STM32 ADC1 sample time macros (bug #1059)
        (backported to 19.1.4)(backported to 18.2.3).
 - FIX: Fixed STM32 ADCv1 error callback disabled on some devices (bug #1058)

test/nil/configuration.xml

@@ -279,10 +279,10 @@ test_println("");]]></value>
               <value>Internal Tests</value>
             </type>
             <brief>
-              <value>Threads Functionality.</value>
+              <value>Time and Intervals Functionality.</value>
             </brief>
             <description>
-              <value>This sequence tests the ChibiOS/NIL functionalities related to threading.</value>
+              <value>This sequence tests the ChibiOS/NIL functionalities related to time and intervals management.</value>
             </description>
             <condition>
               <value />
@@ -328,6 +328,115 @@ while (time == chVTGetSystemTimeX()) {
                   </step>
                 </steps>
               </case>
+              <case>
+                <brief>
+                  <value>Time ranges functionality.</value>
+                </brief>
+                <description>
+                  <value>The functionality of the API @p chTimeIsInRangeX() is tested.</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value />
+                  </setup_code>
+                  <teardown_code>
+                    <value />
+                  </teardown_code>
+                  <local_variables>
+                    <value />
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>Checking case where start == end, it must always evaluate as in range.</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+bool b;
+
+b = chTimeIsInRangeX((systime_t)0, (systime_t)0, (systime_t)0);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)-1, (systime_t)0, (systime_t)0);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)0, (systime_t)-1, (systime_t)-1);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)-1, (systime_t)-1, (systime_t)-1);
+test_assert(b == true, "not in range");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Checking boundaries for start &lt; end.</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+bool b;
+
+b = chTimeIsInRangeX((systime_t)10, (systime_t)10, (systime_t)100);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)9, (systime_t)10, (systime_t)100);
+test_assert(b == false, "in range");
+b = chTimeIsInRangeX((systime_t)99, (systime_t)10, (systime_t)100);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)100, (systime_t)10, (systime_t)100);
+test_assert(b == false, "in range");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Checking boundaries for start &gt; end.</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+bool b;
+
+b = chTimeIsInRangeX((systime_t)100, (systime_t)100, (systime_t)10);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)99, (systime_t)100, (systime_t)10);
+test_assert(b == false, "in range");
+b = chTimeIsInRangeX((systime_t)9, (systime_t)100, (systime_t)10);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)10, (systime_t)100, (systime_t)10);
+test_assert(b == false, "in range");
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
+            </cases>
+          </sequence>
+          <sequence>
+            <type index="0">
+              <value>Internal Tests</value>
+            </type>
+            <brief>
+              <value>Threads Functionality.</value>
+            </brief>
+            <description>
+              <value>This sequence tests the ChibiOS/NIL functionalities related to threading.</value>
+            </description>
+            <condition>
+              <value />
+            </condition>
+            <shared_code>
+              <value><![CDATA[#include "ch.h"]]></value>
+            </shared_code>
+            <cases>
               <case>
                 <brief>
                   <value>Thread Sleep functionality.</value>

test/nil/nil_test.mk

@@ -6,7 +6,8 @@ TESTSRC += ${CHIBIOS}/test/nil/source/test/nil_test_root.c \
            ${CHIBIOS}/test/nil/source/test/nil_test_sequence_004.c \
            ${CHIBIOS}/test/nil/source/test/nil_test_sequence_005.c \
            ${CHIBIOS}/test/nil/source/test/nil_test_sequence_006.c \
-           ${CHIBIOS}/test/nil/source/test/nil_test_sequence_007.c
+           ${CHIBIOS}/test/nil/source/test/nil_test_sequence_007.c \
+           ${CHIBIOS}/test/nil/source/test/nil_test_sequence_008.c
 
 # Required include directories
 TESTINC += ${CHIBIOS}/test/nil/source/test

test/nil/source/test/nil_test_root.c

@@ -28,6 +28,7 @@
  * - @subpage nil_test_sequence_005
  * - @subpage nil_test_sequence_006
  * - @subpage nil_test_sequence_007
+ * - @subpage nil_test_sequence_008
  * .
  */
 
@@ -51,17 +52,18 @@
 const testsequence_t * const nil_test_suite_array[] = {
   &nil_test_sequence_001,
   &nil_test_sequence_002,
-#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
   &nil_test_sequence_003,
-#endif
+#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
   &nil_test_sequence_004,
-#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
-  &nil_test_sequence_005,
 #endif
-#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+  &nil_test_sequence_005,
+#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
   &nil_test_sequence_006,
 #endif
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
   &nil_test_sequence_007,
+#endif
+  &nil_test_sequence_008,
   NULL
 };
 

test/nil/source/test/nil_test_root.h

@@ -31,6 +31,7 @@
 #include "nil_test_sequence_005.h"
 #include "nil_test_sequence_006.h"
 #include "nil_test_sequence_007.h"
+#include "nil_test_sequence_008.h"
 
 #if !defined(__DOXYGEN__)
 

test/nil/source/test/nil_test_sequence_002.c

@@ -21,13 +21,13 @@
  * @file    nil_test_sequence_002.c
  * @brief   Test Sequence 002 code.
  *
- * @page nil_test_sequence_002 [2] Threads Functionality
+ * @page nil_test_sequence_002 [2] Time and Intervals Functionality
  *
  * File: @ref nil_test_sequence_002.c
  *
  * <h2>Description</h2>
- * This sequence tests the ChibiOS/NIL functionalities related to
+ * This sequence tests the ChibiOS/NIL functionalities related to time
- * threading.
+ * and intervals management.
  *
  * <h2>Test Cases</h2>
  * - @subpage nil_test_002_001
@@ -78,97 +78,73 @@ static const testcase_t nil_test_002_001 = {
 };
 
 /**
- * @page nil_test_002_002 [2.2] Thread Sleep functionality
+ * @page nil_test_002_002 [2.2] Time ranges functionality
  *
  * <h2>Description</h2>
- * The functionality of @p chThdSleep() and derivatives is tested.
+ * The functionality of the API @p chTimeIsInRangeX() is tested.
  *
  * <h2>Test Steps</h2>
- * - [2.2.1] The current system time is read then a sleep is performed
+ * - [2.2.1] Checking case where start == end, it must always evaluate
- *   for 100 system ticks and on exit the system time is verified
+ *   as in range.
- *   again.
+ * - [2.2.2] Checking boundaries for start < end.
- * - [2.2.2] The current system time is read then a sleep is performed
+ * - [2.2.3] Checking boundaries for start > end.
- *   for 100000 microseconds and on exit the system time is verified
- *   again.
- * - [2.2.3] The current system time is read then a sleep is performed
- *   for 100 milliseconds and on exit the system time is verified
- *   again.
- * - [2.2.4] The current system time is read then a sleep is performed
- *   for 1 second and on exit the system time is verified again.
- * - [2.2.5] Function chThdSleepUntil() is tested with a timeline of
- *   "now" + 100 ticks.
  * .
  */
 
 static void nil_test_002_002_execute(void) {
-  systime_t time;
 
-  /* [2.2.1] The current system time is read then a sleep is performed
+  /* [2.2.1] Checking case where start == end, it must always evaluate
-     for 100 system ticks and on exit the system time is verified
+     as in range.*/
-     again.*/
   test_set_step(1);
   {
-    time = chVTGetSystemTimeX();
+    bool b;
-    chThdSleep(100);
+
-    test_assert_time_window(chTimeAddX(time, 100),
+    b = chTimeIsInRangeX((systime_t)0, (systime_t)0, (systime_t)0);
-                            chTimeAddX(time, 100 + 1),
+    test_assert(b == true, "not in range");
-                            "out of time window");
+    b = chTimeIsInRangeX((systime_t)-1, (systime_t)0, (systime_t)0);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)0, (systime_t)-1, (systime_t)-1);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)-1, (systime_t)-1, (systime_t)-1);
+    test_assert(b == true, "not in range");
   }
   test_end_step(1);
 
-  /* [2.2.2] The current system time is read then a sleep is performed
+  /* [2.2.2] Checking boundaries for start < end.*/
-     for 100000 microseconds and on exit the system time is verified
-     again.*/
   test_set_step(2);
   {
-    time = chVTGetSystemTimeX();
+    bool b;
-    chThdSleepMicroseconds(100000);
+
-    test_assert_time_window(chTimeAddX(time, TIME_US2I(100000)),
+    b = chTimeIsInRangeX((systime_t)10, (systime_t)10, (systime_t)100);
-                            chTimeAddX(time, TIME_US2I(100000) + 1),
+    test_assert(b == true, "not in range");
-                            "out of time window");
+    b = chTimeIsInRangeX((systime_t)9, (systime_t)10, (systime_t)100);
+    test_assert(b == false, "in range");
+    b = chTimeIsInRangeX((systime_t)99, (systime_t)10, (systime_t)100);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)100, (systime_t)10, (systime_t)100);
+    test_assert(b == false, "in range");
   }
   test_end_step(2);
 
-  /* [2.2.3] The current system time is read then a sleep is performed
+  /* [2.2.3] Checking boundaries for start > end.*/
-     for 100 milliseconds and on exit the system time is verified
-     again.*/
   test_set_step(3);
   {
-    time = chVTGetSystemTimeX();
+    bool b;
-    chThdSleepMilliseconds(100);
+
-    test_assert_time_window(chTimeAddX(time, TIME_MS2I(100)),
+    b = chTimeIsInRangeX((systime_t)100, (systime_t)100, (systime_t)10);
-                            chTimeAddX(time, TIME_MS2I(100) + 1),
+    test_assert(b == true, "not in range");
-                            "out of time window");
+    b = chTimeIsInRangeX((systime_t)99, (systime_t)100, (systime_t)10);
+    test_assert(b == false, "in range");
+    b = chTimeIsInRangeX((systime_t)9, (systime_t)100, (systime_t)10);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)10, (systime_t)100, (systime_t)10);
+    test_assert(b == false, "in range");
   }
   test_end_step(3);
-
-  /* [2.2.4] The current system time is read then a sleep is performed
-     for 1 second and on exit the system time is verified again.*/
-  test_set_step(4);
-  {
-    time = chVTGetSystemTimeX();
-    chThdSleepSeconds(1);
-    test_assert_time_window(chTimeAddX(time, TIME_S2I(1)),
-                            chTimeAddX(time, TIME_S2I(1) + 1),
-                            "out of time window");
-  }
-  test_end_step(4);
-
-  /* [2.2.5] Function chThdSleepUntil() is tested with a timeline of
-     "now" + 100 ticks.*/
-  test_set_step(5);
-  {
-    time = chVTGetSystemTimeX();
-    chThdSleepUntil(chTimeAddX(time, 100));
-    test_assert_time_window(chTimeAddX(time, 100),
-                            chTimeAddX(time, 100 + 1),
-                            "out of time window");
-  }
-  test_end_step(5);
 }
 
 static const testcase_t nil_test_002_002 = {
-  "Thread Sleep functionality",
+  "Time ranges functionality",
   NULL,
   NULL,
   nil_test_002_002_execute
@@ -188,9 +164,9 @@ const testcase_t * const nil_test_sequence_002_array[] = {
 };
 
 /**
- * @brief   Threads Functionality.
+ * @brief   Time and Intervals Functionality.
  */
 const testsequence_t nil_test_sequence_002 = {
-  "Threads Functionality",
+  "Time and Intervals Functionality",
   nil_test_sequence_002_array
 };

test/nil/source/test/nil_test_sequence_003.c

@@ -21,268 +21,126 @@
  * @file    nil_test_sequence_003.c
  * @brief   Test Sequence 003 code.
  *
- * @page nil_test_sequence_003 [3] Semaphores
+ * @page nil_test_sequence_003 [3] Threads Functionality
  *
  * File: @ref nil_test_sequence_003.c
  *
  * <h2>Description</h2>
  * This sequence tests the ChibiOS/NIL functionalities related to
- * counter semaphores.
+ * threading.
- *
- * <h2>Conditions</h2>
- * This sequence is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_SEMAPHORES
- * .
  *
  * <h2>Test Cases</h2>
  * - @subpage nil_test_003_001
- * - @subpage nil_test_003_002
- * - @subpage nil_test_003_003
  * .
  */
 
-#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
-
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
 #include "ch.h"
 
-static thread_t *tp1;
-static bool terminate;
-static semaphore_t sem1, sem2;
-
-/*
- * Signaler thread.
- */
-static THD_FUNCTION(signaler, arg) {
-
-  (void)arg;
-
-  /* Initializing global resources.*/
-  terminate = false;
-  chSemObjectInit(&sem1, 0);
-  chSemObjectInit(&sem2, 0);
-
-  while (!terminate) {
-    chSysLock();
-    if (chSemGetCounterI(&sem1) < 0)
-      chSemSignalI(&sem1);
-    chSemResetI(&sem2, 0);
-    chSchRescheduleS();
-    chSysUnlock();
-
-    chThdSleepMilliseconds(250);
-  }
-}
-
 /****************************************************************************
  * Test cases.
  ****************************************************************************/
 
 /**
- * @page nil_test_003_001 [3.1] Semaphore primitives, no state change
+ * @page nil_test_003_001 [3.1] Thread Sleep functionality
  *
  * <h2>Description</h2>
- * Wait, Signal and Reset primitives are tested. The testing thread
+ * The functionality of @p chThdSleep() and derivatives is tested.
- * does not trigger a state change.
  *
  * <h2>Test Steps</h2>
- * - [3.1.1] The function chSemWait() is invoked, after return the
+ * - [3.1.1] The current system time is read then a sleep is performed
- *   counter and the returned message are tested.
+ *   for 100 system ticks and on exit the system time is verified
- * - [3.1.2] The function chSemSignal() is invoked, after return the
+ *   again.
- *   counter is tested.
+ * - [3.1.2] The current system time is read then a sleep is performed
- * - [3.1.3] The function chSemReset() is invoked, after return the
+ *   for 100000 microseconds and on exit the system time is verified
- *   counter is tested.
+ *   again.
+ * - [3.1.3] The current system time is read then a sleep is performed
+ *   for 100 milliseconds and on exit the system time is verified
+ *   again.
+ * - [3.1.4] The current system time is read then a sleep is performed
+ *   for 1 second and on exit the system time is verified again.
+ * - [3.1.5] Function chThdSleepUntil() is tested with a timeline of
+ *   "now" + 100 ticks.
  * .
  */
 
-static void nil_test_003_001_setup(void) {
-  chSemObjectInit(&sem1, 1);
-}
-
-static void nil_test_003_001_teardown(void) {
-  chSemReset(&sem1, 0);
-}
-
 static void nil_test_003_001_execute(void) {
+  systime_t time;
 
-  /* [3.1.1] The function chSemWait() is invoked, after return the
+  /* [3.1.1] The current system time is read then a sleep is performed
-     counter and the returned message are tested.*/
+     for 100 system ticks and on exit the system time is verified
+     again.*/
   test_set_step(1);
   {
-    msg_t msg;
+    time = chVTGetSystemTimeX();
-
+    chThdSleep(100);
-    msg = chSemWait(&sem1);
+    test_assert_time_window(chTimeAddX(time, 100),
-    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
+                            chTimeAddX(time, 100 + 1),
-    test_assert(MSG_OK == msg, "wrong returned message");
+                            "out of time window");
   }
   test_end_step(1);
 
-  /* [3.1.2] The function chSemSignal() is invoked, after return the
+  /* [3.1.2] The current system time is read then a sleep is performed
-     counter is tested.*/
+     for 100000 microseconds and on exit the system time is verified
+     again.*/
   test_set_step(2);
   {
-    chSemSignal(&sem1);
+    time = chVTGetSystemTimeX();
-    test_assert_lock(chSemGetCounterI(&sem1) == 1, "wrong counter value");
+    chThdSleepMicroseconds(100000);
+    test_assert_time_window(chTimeAddX(time, TIME_US2I(100000)),
+                            chTimeAddX(time, TIME_US2I(100000) + 1),
+                            "out of time window");
   }
   test_end_step(2);
 
-  /* [3.1.3] The function chSemReset() is invoked, after return the
+  /* [3.1.3] The current system time is read then a sleep is performed
-     counter is tested.*/
+     for 100 milliseconds and on exit the system time is verified
+     again.*/
   test_set_step(3);
   {
-    chSemReset(&sem1, 2);
+    time = chVTGetSystemTimeX();
-    test_assert_lock(chSemGetCounterI(&sem1) == 2, "wrong counter value");
+    chThdSleepMilliseconds(100);
+    test_assert_time_window(chTimeAddX(time, TIME_MS2I(100)),
+                            chTimeAddX(time, TIME_MS2I(100) + 1),
+                            "out of time window");
   }
   test_end_step(3);
+
+  /* [3.1.4] The current system time is read then a sleep is performed
+     for 1 second and on exit the system time is verified again.*/
+  test_set_step(4);
+  {
+    time = chVTGetSystemTimeX();
+    chThdSleepSeconds(1);
+    test_assert_time_window(chTimeAddX(time, TIME_S2I(1)),
+                            chTimeAddX(time, TIME_S2I(1) + 1),
+                            "out of time window");
+  }
+  test_end_step(4);
+
+  /* [3.1.5] Function chThdSleepUntil() is tested with a timeline of
+     "now" + 100 ticks.*/
+  test_set_step(5);
+  {
+    time = chVTGetSystemTimeX();
+    chThdSleepUntil(chTimeAddX(time, 100));
+    test_assert_time_window(chTimeAddX(time, 100),
+                            chTimeAddX(time, 100 + 1),
+                            "out of time window");
+  }
+  test_end_step(5);
 }
 
 static const testcase_t nil_test_003_001 = {
-  "Semaphore primitives, no state change",
+  "Thread Sleep functionality",
-  nil_test_003_001_setup,
+  NULL,
-  nil_test_003_001_teardown,
+  NULL,
   nil_test_003_001_execute
 };
 
-/**
- * @page nil_test_003_002 [3.2] Semaphore primitives, with state change
- *
- * <h2>Description</h2>
- * Wait, Signal and Reset primitives are tested. The testing thread
- * triggers a state change.
- *
- * <h2>Test Steps</h2>
- * - [3.2.1] The function chSemWait() is invoked, after return the
- *   counter and the returned message are tested. The semaphore is
- *   signaled by another thread.
- * - [3.2.2] The function chSemWait() is invoked, after return the
- *   counter and the returned message are tested. The semaphore is
- *   reset by another thread.
- * .
- */
-
-static void nil_test_003_002_setup(void) {
-  thread_descriptor_t td = {
-    .name  = "signaler",
-    .wbase = wa_common,
-    .wend  = THD_WORKING_AREA_END(wa_common),
-    .prio  = chThdGetPriorityX() - 1,
-    .funcp = signaler,
-    .arg   = NULL
-  };
-  tp1 = chThdCreate(&td);
-}
-
-static void nil_test_003_002_teardown(void) {
-  terminate = true;
-  chThdWait(tp1);
-}
-
-static void nil_test_003_002_execute(void) {
-
-  /* [3.2.1] The function chSemWait() is invoked, after return the
-     counter and the returned message are tested. The semaphore is
-     signaled by another thread.*/
-  test_set_step(1);
-  {
-    msg_t msg;
-
-    msg = chSemWait(&sem1);
-    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
-    test_assert(MSG_OK == msg, "wrong returned message");
-  }
-  test_end_step(1);
-
-  /* [3.2.2] The function chSemWait() is invoked, after return the
-     counter and the returned message are tested. The semaphore is
-     reset by another thread.*/
-  test_set_step(2);
-  {
-    msg_t msg;
-
-    msg = chSemWait(&sem2);
-    test_assert_lock(chSemGetCounterI(&sem2) == 0,"wrong counter value");
-    test_assert(MSG_RESET == msg, "wrong returned message");
-  }
-  test_end_step(2);
-}
-
-static const testcase_t nil_test_003_002 = {
-  "Semaphore primitives, with state change",
-  nil_test_003_002_setup,
-  nil_test_003_002_teardown,
-  nil_test_003_002_execute
-};
-
-/**
- * @page nil_test_003_003 [3.3] Semaphores timeout
- *
- * <h2>Description</h2>
- * Timeout on semaphores is tested.
- *
- * <h2>Test Steps</h2>
- * - [3.3.1] The function chSemWaitTimeout() is invoked a first time,
- *   after return the system time, the counter and the returned message
- *   are tested.
- * - [3.3.2] The function chSemWaitTimeout() is invoked again, after
- *   return the system time, the counter and the returned message are
- *   tested.
- * .
- */
-
-static void nil_test_003_003_setup(void) {
-  chSemObjectInit(&sem1, 0);
-}
-
-static void nil_test_003_003_teardown(void) {
-  chSemReset(&sem1, 0);
-}
-
-static void nil_test_003_003_execute(void) {
-  systime_t time;
-  msg_t msg;
-
-  /* [3.3.1] The function chSemWaitTimeout() is invoked a first time,
-     after return the system time, the counter and the returned message
-     are tested.*/
-  test_set_step(1);
-  {
-    time = chVTGetSystemTimeX();
-    msg = chSemWaitTimeout(&sem1, TIME_MS2I(1000));
-    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
-                            chTimeAddX(time, TIME_MS2I(1000) + 1),
-                            "out of time window");
-    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
-    test_assert(MSG_TIMEOUT == msg, "wrong timeout message");
-  }
-  test_end_step(1);
-
-  /* [3.3.2] The function chSemWaitTimeout() is invoked again, after
-     return the system time, the counter and the returned message are
-     tested.*/
-  test_set_step(2);
-  {
-    time = chVTGetSystemTimeX();
-    msg = chSemWaitTimeout(&sem1, TIME_MS2I(1000));
-    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
-                            chTimeAddX(time, TIME_MS2I(1000) + 1),
-                            "out of time window");
-    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
-    test_assert(MSG_TIMEOUT == msg, "wrong timeout message");
-  }
-  test_end_step(2);
-}
-
-static const testcase_t nil_test_003_003 = {
-  "Semaphores timeout",
-  nil_test_003_003_setup,
-  nil_test_003_003_teardown,
-  nil_test_003_003_execute
-};
-
 /****************************************************************************
  * Exported data.
  ****************************************************************************/
@@ -292,17 +150,13 @@ static const testcase_t nil_test_003_003 = {
  */
 const testcase_t * const nil_test_sequence_003_array[] = {
   &nil_test_003_001,
-  &nil_test_003_002,
-  &nil_test_003_003,
   NULL
 };
 
 /**
- * @brief   Semaphores.
+ * @brief   Threads Functionality.
  */
 const testsequence_t nil_test_sequence_003 = {
-  "Semaphores",
+  "Threads Functionality",
   nil_test_sequence_003_array
 };
-
-#endif /* CH_CFG_USE_SEMAPHORES */

test/nil/source/test/nil_test_sequence_004.c

@@ -21,40 +21,59 @@
  * @file    nil_test_sequence_004.c
  * @brief   Test Sequence 004 code.
  *
- * @page nil_test_sequence_004 [4] Suspend/Resume
+ * @page nil_test_sequence_004 [4] Semaphores
  *
  * File: @ref nil_test_sequence_004.c
  *
  * <h2>Description</h2>
  * This sequence tests the ChibiOS/NIL functionalities related to
- * threads suspend/resume.
+ * counter semaphores.
+ *
+ * <h2>Conditions</h2>
+ * This sequence is only executed if the following preprocessor condition
+ * evaluates to true:
+ * - CH_CFG_USE_SEMAPHORES
+ * .
  *
  * <h2>Test Cases</h2>
  * - @subpage nil_test_004_001
+ * - @subpage nil_test_004_002
+ * - @subpage nil_test_004_003
  * .
  */
 
+#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
+
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
+#include "ch.h"
+
 static thread_t *tp1;
 static bool terminate;
-static thread_reference_t tr1;
+static semaphore_t sem1, sem2;
 
 /*
- * Resumer thread.
+ * Signaler thread.
  */
-static THD_FUNCTION(resumer, arg) {
+static THD_FUNCTION(signaler, arg) {
 
   (void)arg;
 
   /* Initializing global resources.*/
   terminate = false;
-  tr1 = NULL;
+  chSemObjectInit(&sem1, 0);
+  chSemObjectInit(&sem2, 0);
 
   while (!terminate) {
-    chThdResume(&tr1, MSG_OK);
+    chSysLock();
+    if (chSemGetCounterI(&sem1) < 0)
+      chSemSignalI(&sem1);
+    chSemResetI(&sem2, 0);
+    chSchRescheduleS();
+    chSysUnlock();
+
     chThdSleepMilliseconds(250);
   }
 }
@@ -64,81 +83,204 @@ static THD_FUNCTION(resumer, arg) {
  ****************************************************************************/
 
 /**
- * @page nil_test_004_001 [4.1] Suspend and Resume functionality
+ * @page nil_test_004_001 [4.1] Semaphore primitives, no state change
  *
  * <h2>Description</h2>
- * The functionality of chThdSuspendTimeoutS() and chThdResumeI() is
+ * Wait, Signal and Reset primitives are tested. The testing thread
- * tested.
+ * does not trigger a state change.
  *
  * <h2>Test Steps</h2>
- * - [4.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
+ * - [4.1.1] The function chSemWait() is invoked, after return the
- *   is remotely resumed with message @p MSG_OK. On return the message
+ *   counter and the returned message are tested.
- *   and the state of the reference are tested.
+ * - [4.1.2] The function chSemSignal() is invoked, after return the
- * - [4.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
+ *   counter is tested.
- *   is not resumed so a timeout must occur. On return the message and
+ * - [4.1.3] The function chSemReset() is invoked, after return the
- *   the state of the reference are tested.
+ *   counter is tested.
  * .
  */
 
 static void nil_test_004_001_setup(void) {
+  chSemObjectInit(&sem1, 1);
+}
+
+static void nil_test_004_001_teardown(void) {
+  chSemReset(&sem1, 0);
+}
+
+static void nil_test_004_001_execute(void) {
+
+  /* [4.1.1] The function chSemWait() is invoked, after return the
+     counter and the returned message are tested.*/
+  test_set_step(1);
+  {
+    msg_t msg;
+
+    msg = chSemWait(&sem1);
+    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
+    test_assert(MSG_OK == msg, "wrong returned message");
+  }
+  test_end_step(1);
+
+  /* [4.1.2] The function chSemSignal() is invoked, after return the
+     counter is tested.*/
+  test_set_step(2);
+  {
+    chSemSignal(&sem1);
+    test_assert_lock(chSemGetCounterI(&sem1) == 1, "wrong counter value");
+  }
+  test_end_step(2);
+
+  /* [4.1.3] The function chSemReset() is invoked, after return the
+     counter is tested.*/
+  test_set_step(3);
+  {
+    chSemReset(&sem1, 2);
+    test_assert_lock(chSemGetCounterI(&sem1) == 2, "wrong counter value");
+  }
+  test_end_step(3);
+}
+
+static const testcase_t nil_test_004_001 = {
+  "Semaphore primitives, no state change",
+  nil_test_004_001_setup,
+  nil_test_004_001_teardown,
+  nil_test_004_001_execute
+};
+
+/**
+ * @page nil_test_004_002 [4.2] Semaphore primitives, with state change
+ *
+ * <h2>Description</h2>
+ * Wait, Signal and Reset primitives are tested. The testing thread
+ * triggers a state change.
+ *
+ * <h2>Test Steps</h2>
+ * - [4.2.1] The function chSemWait() is invoked, after return the
+ *   counter and the returned message are tested. The semaphore is
+ *   signaled by another thread.
+ * - [4.2.2] The function chSemWait() is invoked, after return the
+ *   counter and the returned message are tested. The semaphore is
+ *   reset by another thread.
+ * .
+ */
+
+static void nil_test_004_002_setup(void) {
   thread_descriptor_t td = {
-    .name  = "resumer",
+    .name  = "signaler",
     .wbase = wa_common,
     .wend  = THD_WORKING_AREA_END(wa_common),
     .prio  = chThdGetPriorityX() - 1,
-    .funcp = resumer,
+    .funcp = signaler,
     .arg   = NULL
   };
   tp1 = chThdCreate(&td);
 }
 
-static void nil_test_004_001_teardown(void) {
+static void nil_test_004_002_teardown(void) {
   terminate = true;
   chThdWait(tp1);
 }
 
-static void nil_test_004_001_execute(void) {
+static void nil_test_004_002_execute(void) {
-  systime_t time;
-  msg_t msg;
 
-  /* [4.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
+  /* [4.2.1] The function chSemWait() is invoked, after return the
-     is remotely resumed with message @p MSG_OK. On return the message
+     counter and the returned message are tested. The semaphore is
-     and the state of the reference are tested.*/
+     signaled by another thread.*/
   test_set_step(1);
   {
-    chSysLock();
+    msg_t msg;
-    msg = chThdSuspendTimeoutS(&tr1, TIME_INFINITE);
+
-    chSysUnlock();
+    msg = chSemWait(&sem1);
-    test_assert(NULL == tr1, "not NULL");
+    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
-    test_assert(MSG_OK == msg,"wrong returned message");
+    test_assert(MSG_OK == msg, "wrong returned message");
   }
   test_end_step(1);
 
-  /* [4.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
+  /* [4.2.2] The function chSemWait() is invoked, after return the
-     is not resumed so a timeout must occur. On return the message and
+     counter and the returned message are tested. The semaphore is
-     the state of the reference are tested.*/
+     reset by another thread.*/
   test_set_step(2);
   {
-    thread_reference_t tr = NULL;
+    msg_t msg;
 
-    chSysLock();
+    msg = chSemWait(&sem2);
-    time = chVTGetSystemTimeX();
+    test_assert_lock(chSemGetCounterI(&sem2) == 0,"wrong counter value");
-    msg = chThdSuspendTimeoutS(&tr, TIME_MS2I(1000));
+    test_assert(MSG_RESET == msg, "wrong returned message");
-    chSysUnlock();
-    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
-                            chTimeAddX(time, TIME_MS2I(1000) + 1),
-                            "out of time window");
-    test_assert(NULL == tr, "not NULL");
-    test_assert(MSG_TIMEOUT == msg, "wrong returned message");
   }
   test_end_step(2);
 }
 
-static const testcase_t nil_test_004_001 = {
+static const testcase_t nil_test_004_002 = {
-  "Suspend and Resume functionality",
+  "Semaphore primitives, with state change",
-  nil_test_004_001_setup,
+  nil_test_004_002_setup,
-  nil_test_004_001_teardown,
+  nil_test_004_002_teardown,
-  nil_test_004_001_execute
+  nil_test_004_002_execute
+};
+
+/**
+ * @page nil_test_004_003 [4.3] Semaphores timeout
+ *
+ * <h2>Description</h2>
+ * Timeout on semaphores is tested.
+ *
+ * <h2>Test Steps</h2>
+ * - [4.3.1] The function chSemWaitTimeout() is invoked a first time,
+ *   after return the system time, the counter and the returned message
+ *   are tested.
+ * - [4.3.2] The function chSemWaitTimeout() is invoked again, after
+ *   return the system time, the counter and the returned message are
+ *   tested.
+ * .
+ */
+
+static void nil_test_004_003_setup(void) {
+  chSemObjectInit(&sem1, 0);
+}
+
+static void nil_test_004_003_teardown(void) {
+  chSemReset(&sem1, 0);
+}
+
+static void nil_test_004_003_execute(void) {
+  systime_t time;
+  msg_t msg;
+
+  /* [4.3.1] The function chSemWaitTimeout() is invoked a first time,
+     after return the system time, the counter and the returned message
+     are tested.*/
+  test_set_step(1);
+  {
+    time = chVTGetSystemTimeX();
+    msg = chSemWaitTimeout(&sem1, TIME_MS2I(1000));
+    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
+                            chTimeAddX(time, TIME_MS2I(1000) + 1),
+                            "out of time window");
+    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
+    test_assert(MSG_TIMEOUT == msg, "wrong timeout message");
+  }
+  test_end_step(1);
+
+  /* [4.3.2] The function chSemWaitTimeout() is invoked again, after
+     return the system time, the counter and the returned message are
+     tested.*/
+  test_set_step(2);
+  {
+    time = chVTGetSystemTimeX();
+    msg = chSemWaitTimeout(&sem1, TIME_MS2I(1000));
+    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
+                            chTimeAddX(time, TIME_MS2I(1000) + 1),
+                            "out of time window");
+    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
+    test_assert(MSG_TIMEOUT == msg, "wrong timeout message");
+  }
+  test_end_step(2);
+}
+
+static const testcase_t nil_test_004_003 = {
+  "Semaphores timeout",
+  nil_test_004_003_setup,
+  nil_test_004_003_teardown,
+  nil_test_004_003_execute
 };
 
 /****************************************************************************
@@ -150,13 +292,17 @@ static const testcase_t nil_test_004_001 = {
  */
 const testcase_t * const nil_test_sequence_004_array[] = {
   &nil_test_004_001,
+  &nil_test_004_002,
+  &nil_test_004_003,
   NULL
 };
 
 /**
- * @brief   Suspend/Resume.
+ * @brief   Semaphores.
  */
 const testsequence_t nil_test_sequence_004 = {
-  "Suspend/Resume",
+  "Semaphores",
   nil_test_sequence_004_array
 };
+
+#endif /* CH_CFG_USE_SEMAPHORES */

test/nil/source/test/nil_test_sequence_005.c

@@ -21,62 +21,42 @@
  * @file    nil_test_sequence_005.c
  * @brief   Test Sequence 005 code.
  *
- * @page nil_test_sequence_005 [5] Event Sources and Event Flags
+ * @page nil_test_sequence_005 [5] Suspend/Resume
  *
  * File: @ref nil_test_sequence_005.c
  *
  * <h2>Description</h2>
- * This module implements the test sequence for the Events subsystem.
+ * This sequence tests the ChibiOS/NIL functionalities related to
- *
+ * threads suspend/resume.
- * <h2>Conditions</h2>
- * This sequence is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_EVENTS
- * .
  *
  * <h2>Test Cases</h2>
  * - @subpage nil_test_005_001
- * - @subpage nil_test_005_002
- * - @subpage nil_test_005_003
- * - @subpage nil_test_005_004
- * - @subpage nil_test_005_005
- * - @subpage nil_test_005_006
- * - @subpage nil_test_005_007
  * .
  */
 
-#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
-
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
-static EVENTSOURCE_DECL(es1);
+static thread_t *tp1;
-static EVENTSOURCE_DECL(es2);
+static bool terminate;
-
+static thread_reference_t tr1;
-static void h1(eventid_t id) {(void)id;test_emit_token('A');}
-static void h2(eventid_t id) {(void)id;test_emit_token('B');}
-static void h3(eventid_t id) {(void)id;test_emit_token('C');}
-static ROMCONST evhandler_t evhndl[] = {h1, h2, h3};
 
 /*
- * Direct events thread.
+ * Resumer thread.
  */
-static THD_FUNCTION(evtthd1, p) {
+static THD_FUNCTION(resumer, arg) {
 
-  chThdSleepMilliseconds(50);
+  (void)arg;
-  chEvtSignal((thread_t *)p, 1);
-}
 
-/*
+  /* Initializing global resources.*/
- * Broadcaster thread.
+  terminate = false;
- */
+  tr1 = NULL;
-static THD_FUNCTION(evtthd2, p) {
 
-  (void)p;
+  while (!terminate) {
-  chEvtBroadcast(&es1);
+    chThdResume(&tr1, MSG_OK);
-  chThdSleepMilliseconds(50);
+    chThdSleepMilliseconds(250);
-  chEvtBroadcast(&es2);
+  }
 }
 
 /****************************************************************************
@@ -84,525 +64,83 @@ static THD_FUNCTION(evtthd2, p) {
  ****************************************************************************/
 
 /**
- * @page nil_test_005_001 [5.1] Events registration
+ * @page nil_test_005_001 [5.1] Suspend and Resume functionality
  *
  * <h2>Description</h2>
- * Two event listeners are registered on an event source and then
+ * The functionality of chThdSuspendTimeoutS() and chThdResumeI() is
- * unregistered in the same order.<br> The test expects that the even
+ * tested.
- * source has listeners after the registrations and after the first
- * unregistration, then, after the second unegistration, the test
- * expects no more listeners.
  *
  * <h2>Test Steps</h2>
- * - [5.1.1] An Event Source is initialized.
+ * - [5.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
- * - [5.1.2] Two Event Listeners are registered on the Event Source,
+ *   is remotely resumed with message @p MSG_OK. On return the message
- *   the Event Source is tested to have listeners.
+ *   and the state of the reference are tested.
- * - [5.1.3] An Event Listener is unregistered, the Event Source must
+ * - [5.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
- *   still have listeners.
+ *   is not resumed so a timeout must occur. On return the message and
- * - [5.1.4] An Event Listener is unregistered, the Event Source must
+ *   the state of the reference are tested.
- *   not have listeners.
  * .
  */
 
-static void nil_test_005_001_execute(void) {
+static void nil_test_005_001_setup(void) {
-  event_listener_t el1, el2;
+  thread_descriptor_t td = {
+    .name  = "resumer",
+    .wbase = wa_common,
+    .wend  = THD_WORKING_AREA_END(wa_common),
+    .prio  = chThdGetPriorityX() - 1,
+    .funcp = resumer,
+    .arg   = NULL
+  };
+  tp1 = chThdCreate(&td);
+}
 
-  /* [5.1.1] An Event Source is initialized.*/
+static void nil_test_005_001_teardown(void) {
+  terminate = true;
+  chThdWait(tp1);
+}
+
+static void nil_test_005_001_execute(void) {
+  systime_t time;
+  msg_t msg;
+
+  /* [5.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
+     is remotely resumed with message @p MSG_OK. On return the message
+     and the state of the reference are tested.*/
   test_set_step(1);
   {
-    chEvtObjectInit(&es1);
+    chSysLock();
+    msg = chThdSuspendTimeoutS(&tr1, TIME_INFINITE);
+    chSysUnlock();
+    test_assert(NULL == tr1, "not NULL");
+    test_assert(MSG_OK == msg,"wrong returned message");
   }
   test_end_step(1);
 
-  /* [5.1.2] Two Event Listeners are registered on the Event Source,
+  /* [5.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
-     the Event Source is tested to have listeners.*/
+     is not resumed so a timeout must occur. On return the message and
+     the state of the reference are tested.*/
   test_set_step(2);
   {
-    chEvtRegisterMask(&es1, &el1, 1);
+    thread_reference_t tr = NULL;
-    chEvtRegisterMask(&es1, &el2, 2);
+
-    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
+    chSysLock();
+    time = chVTGetSystemTimeX();
+    msg = chThdSuspendTimeoutS(&tr, TIME_MS2I(1000));
+    chSysUnlock();
+    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
+                            chTimeAddX(time, TIME_MS2I(1000) + 1),
+                            "out of time window");
+    test_assert(NULL == tr, "not NULL");
+    test_assert(MSG_TIMEOUT == msg, "wrong returned message");
   }
   test_end_step(2);
-
-  /* [5.1.3] An Event Listener is unregistered, the Event Source must
-     still have listeners.*/
-  test_set_step(3);
-  {
-    chEvtUnregister(&es1, &el1);
-    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
-  }
-  test_end_step(3);
-
-  /* [5.1.4] An Event Listener is unregistered, the Event Source must
-     not have listeners.*/
-  test_set_step(4);
-  {
-    chEvtUnregister(&es1, &el2);
-    test_assert_lock(!chEvtIsListeningI(&es1), "stuck listener");
-  }
-  test_end_step(4);
 }
 
 static const testcase_t nil_test_005_001 = {
-  "Events registration",
+  "Suspend and Resume functionality",
-  NULL,
+  nil_test_005_001_setup,
-  NULL,
+  nil_test_005_001_teardown,
   nil_test_005_001_execute
 };
 
-/**
- * @page nil_test_005_002 [5.2] Event Flags dispatching
- *
- * <h2>Description</h2>
- * The test dispatches three event flags and verifies that the
- * associated event handlers are invoked in LSb-first order.
- *
- * <h2>Test Steps</h2>
- * - [5.2.1] Three evenf flag bits are raised then chEvtDispatch() is
- *   invoked, the sequence of handlers calls is tested.
- * .
- */
-
-static void nil_test_005_002_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void nil_test_005_002_execute(void) {
-
-  /* [5.2.1] Three evenf flag bits are raised then chEvtDispatch() is
-     invoked, the sequence of handlers calls is tested.*/
-  test_set_step(1);
-  {
-    chEvtDispatch(evhndl, 7);
-    test_assert_sequence("ABC", "invalid sequence");
-  }
-  test_end_step(1);
-}
-
-static const testcase_t nil_test_005_002 = {
-  "Event Flags dispatching",
-  nil_test_005_002_setup,
-  NULL,
-  nil_test_005_002_execute
-};
-
-/**
- * @page nil_test_005_003 [5.3] Events Flags wait using chEvtWaitOne()
- *
- * <h2>Description</h2>
- * Functionality of chEvtWaitOne() is tested under various scenarios.
- *
- * <h2>Test Steps</h2>
- * - [5.3.1] Setting three event flags.
- * - [5.3.2] Calling chEvtWaitOne() three times, each time a single
- *   flag must be returned in order of priority.
- * - [5.3.3] Getting current time and starting a signaler thread, the
- *   thread will set an event flag after 50mS.
- * - [5.3.4] Calling chEvtWaitOne() then verifying that the event has
- *   been received after 50mS and that the event flags mask has been
- *   emptied.
- * .
- */
-
-static void nil_test_005_003_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void nil_test_005_003_execute(void) {
-  eventmask_t m;
-  systime_t target_time;
-  thread_t *tp;
-
-  /* [5.3.1] Setting three event flags.*/
-  test_set_step(1);
-  {
-    chEvtAddEvents(7);
-  }
-  test_end_step(1);
-
-  /* [5.3.2] Calling chEvtWaitOne() three times, each time a single
-     flag must be returned in order of priority.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert(m == 1, "single event error");
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert(m == 2, "single event error");
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert(m == 4, "single event error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-  }
-  test_end_step(2);
-
-  /* [5.3.3] Getting current time and starting a signaler thread, the
-     thread will set an event flag after 50mS.*/
-  test_set_step(3);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    thread_descriptor_t td = {
-      .name  = "event1",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() + 1,
-      .funcp = evtthd1,
-      .arg   = chThdGetSelfX()
-    };
-    tp = chThdCreate(&td);
-  }
-  test_end_step(3);
-
-  /* [5.3.4] Calling chEvtWaitOne() then verifying that the event has
-     been received after 50mS and that the event flags mask has been
-     emptied.*/
-  test_set_step(4);
-  {
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    test_assert(m == 1, "event flag error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    chThdWait(tp);
-  }
-  test_end_step(4);
-}
-
-static const testcase_t nil_test_005_003 = {
-  "Events Flags wait using chEvtWaitOne()",
-  nil_test_005_003_setup,
-  NULL,
-  nil_test_005_003_execute
-};
-
-/**
- * @page nil_test_005_004 [5.4] Events Flags wait using chEvtWaitAny()
- *
- * <h2>Description</h2>
- * Functionality of chEvtWaitAny() is tested under various scenarios.
- *
- * <h2>Test Steps</h2>
- * - [5.4.1] Setting two, non contiguous, event flags.
- * - [5.4.2] Calling chEvtWaitAny() one time, the two flags must be
- *   returned.
- * - [5.4.3] Getting current time and starting a signaler thread, the
- *   thread will set an event flag after 50mS.
- * - [5.4.4] Calling chEvtWaitAny() then verifying that the event has
- *   been received after 50mS and that the event flags mask has been
- *   emptied.
- * .
- */
-
-static void nil_test_005_004_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void nil_test_005_004_execute(void) {
-  eventmask_t m;
-  systime_t target_time;
-  thread_t *tp;
-
-  /* [5.4.1] Setting two, non contiguous, event flags.*/
-  test_set_step(1);
-  {
-    chEvtAddEvents(5);
-  }
-  test_end_step(1);
-
-  /* [5.4.2] Calling chEvtWaitAny() one time, the two flags must be
-     returned.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitAny(ALL_EVENTS);
-    test_assert(m == 5, "unexpected pending bit");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-  }
-  test_end_step(2);
-
-  /* [5.4.3] Getting current time and starting a signaler thread, the
-     thread will set an event flag after 50mS.*/
-  test_set_step(3);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    thread_descriptor_t td = {
-      .name  = "event1",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() + 1,
-      .funcp = evtthd1,
-      .arg   = chThdGetSelfX()
-    };
-    tp = chThdCreate(&td);
-  }
-  test_end_step(3);
-
-  /* [5.4.4] Calling chEvtWaitAny() then verifying that the event has
-     been received after 50mS and that the event flags mask has been
-     emptied.*/
-  test_set_step(4);
-  {
-    m = chEvtWaitAny(ALL_EVENTS);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    test_assert(m == 1, "event flag error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    chThdWait(tp);
-  }
-  test_end_step(4);
-}
-
-static const testcase_t nil_test_005_004 = {
-  "Events Flags wait using chEvtWaitAny()",
-  nil_test_005_004_setup,
-  NULL,
-  nil_test_005_004_execute
-};
-
-/**
- * @page nil_test_005_005 [5.5] Events Flags wait using chEvtWaitAll()
- *
- * <h2>Description</h2>
- * Functionality of chEvtWaitAll() is tested under various scenarios.
- *
- * <h2>Test Steps</h2>
- * - [5.5.1] Setting two, non contiguous, event flags.
- * - [5.5.2] Calling chEvtWaitAll() one time, the two flags must be
- *   returned.
- * - [5.5.3] Setting one event flag.
- * - [5.5.4] Getting current time and starting a signaler thread, the
- *   thread will set another event flag after 50mS.
- * - [5.5.5] Calling chEvtWaitAll() then verifying that both event
- *   flags have been received after 50mS and that the event flags mask
- *   has been emptied.
- * .
- */
-
-static void nil_test_005_005_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void nil_test_005_005_execute(void) {
-  eventmask_t m;
-  systime_t target_time;
-  thread_t *tp;
-
-  /* [5.5.1] Setting two, non contiguous, event flags.*/
-  test_set_step(1);
-  {
-    chEvtAddEvents(5);
-  }
-  test_end_step(1);
-
-  /* [5.5.2] Calling chEvtWaitAll() one time, the two flags must be
-     returned.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitAll(5);
-    test_assert(m == 5, "unexpected pending bit");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-  }
-  test_end_step(2);
-
-  /* [5.5.3] Setting one event flag.*/
-  test_set_step(3);
-  {
-    chEvtAddEvents(4);
-  }
-  test_end_step(3);
-
-  /* [5.5.4] Getting current time and starting a signaler thread, the
-     thread will set another event flag after 50mS.*/
-  test_set_step(4);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    thread_descriptor_t td = {
-      .name  = "event1",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() + 1,
-      .funcp = evtthd1,
-      .arg   = chThdGetSelfX()
-    };
-    tp = chThdCreate(&td);
-  }
-  test_end_step(4);
-
-  /* [5.5.5] Calling chEvtWaitAll() then verifying that both event
-     flags have been received after 50mS and that the event flags mask
-     has been emptied.*/
-  test_set_step(5);
-  {
-    m = chEvtWaitAll(5);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    test_assert(m == 5, "event flags error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    chThdWait(tp);
-  }
-  test_end_step(5);
-}
-
-static const testcase_t nil_test_005_005 = {
-  "Events Flags wait using chEvtWaitAll()",
-  nil_test_005_005_setup,
-  NULL,
-  nil_test_005_005_execute
-};
-
-/**
- * @page nil_test_005_006 [5.6] Events Flags wait timeouts
- *
- * <h2>Description</h2>
- * Timeout functionality is tested for chEvtWaitOneTimeout(),
- * chEvtWaitAnyTimeout() and chEvtWaitAllTimeout().
- *
- * <h2>Test Steps</h2>
- * - [5.6.1] The functions are invoked first with TIME_IMMEDIATE
- *   timeout, the timeout condition is tested.
- * - [5.6.2] The functions are invoked first with a 50mS timeout, the
- *   timeout condition is tested.
- * .
- */
-
-static void nil_test_005_006_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void nil_test_005_006_execute(void) {
-  eventmask_t m;
-
-  /* [5.6.1] The functions are invoked first with TIME_IMMEDIATE
-     timeout, the timeout condition is tested.*/
-  test_set_step(1);
-  {
-    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_IMMEDIATE);
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_IMMEDIATE);
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_IMMEDIATE);
-    test_assert(m == 0, "spurious event");
-  }
-  test_end_step(1);
-
-  /* [5.6.2] The functions are invoked first with a 50mS timeout, the
-     timeout condition is tested.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_MS2I(50));
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_MS2I(50));
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_MS2I(50));
-    test_assert(m == 0, "spurious event");
-  }
-  test_end_step(2);
-}
-
-static const testcase_t nil_test_005_006 = {
-  "Events Flags wait timeouts",
-  nil_test_005_006_setup,
-  NULL,
-  nil_test_005_006_execute
-};
-
-/**
- * @page nil_test_005_007 [5.7] Broadcasting using chEvtBroadcast()
- *
- * <h2>Description</h2>
- * Functionality of chEvtBroadcast() is tested.
- *
- * <h2>Test Steps</h2>
- * - [5.7.1] Registering on two event sources associating them with
- *   flags 1 and 4.
- * - [5.7.2] Getting current time and starting a broadcaster thread,
- *   the thread broadcast the first Event Source immediately and the
- *   other after 50mS.
- * - [5.7.3] Calling chEvtWaitAll() then verifying that both event
- *   flags have been received after 50mS and that the event flags mask
- *   has been emptied.
- * - [5.7.4] Unregistering from the Event Sources.
- * .
- */
-
-static void nil_test_005_007_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-  chEvtObjectInit(&es1);
-  chEvtObjectInit(&es2);
-}
-
-static void nil_test_005_007_execute(void) {
-  eventmask_t m;
-  event_listener_t el1, el2;
-  systime_t target_time;
-  thread_t *tp;
-
-  /* [5.7.1] Registering on two event sources associating them with
-     flags 1 and 4.*/
-  test_set_step(1);
-  {
-    chEvtRegisterMask(&es1, &el1, 1);
-    chEvtRegisterMask(&es2, &el2, 4);
-  }
-  test_end_step(1);
-
-  /* [5.7.2] Getting current time and starting a broadcaster thread,
-     the thread broadcast the first Event Source immediately and the
-     other after 50mS.*/
-  test_set_step(2);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    thread_descriptor_t td = {
-      .name  = "event2",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() + 1,
-      .funcp = evtthd2,
-      .arg   = NULL
-    };
-    tp = chThdCreate(&td);
-  }
-  test_end_step(2);
-
-  /* [5.7.3] Calling chEvtWaitAll() then verifying that both event
-     flags have been received after 50mS and that the event flags mask
-     has been emptied.*/
-  test_set_step(3);
-  {
-    m = chEvtWaitAll(5);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    chThdWait(tp);
-  }
-  test_end_step(3);
-
-  /* [5.7.4] Unregistering from the Event Sources.*/
-  test_set_step(4);
-  {
-    chEvtUnregister(&es1, &el1);
-    chEvtUnregister(&es2, &el2);
-    test_assert(!chEvtIsListeningI(&es1), "stuck listener");
-    test_assert(!chEvtIsListeningI(&es2), "stuck listener");
-  }
-  test_end_step(4);
-}
-
-static const testcase_t nil_test_005_007 = {
-  "Broadcasting using chEvtBroadcast()",
-  nil_test_005_007_setup,
-  NULL,
-  nil_test_005_007_execute
-};
-
 /****************************************************************************
  * Exported data.
  ****************************************************************************/
@@ -612,21 +150,13 @@ static const testcase_t nil_test_005_007 = {
  */
 const testcase_t * const nil_test_sequence_005_array[] = {
   &nil_test_005_001,
-  &nil_test_005_002,
-  &nil_test_005_003,
-  &nil_test_005_004,
-  &nil_test_005_005,
-  &nil_test_005_006,
-  &nil_test_005_007,
   NULL
 };
 
 /**
- * @brief   Event Sources and Event Flags.
+ * @brief   Suspend/Resume.
  */
 const testsequence_t nil_test_sequence_005 = {
-  "Event Sources and Event Flags",
+  "Suspend/Resume",
   nil_test_sequence_005_array
 };
-
-#endif /* CH_CFG_USE_EVENTS */

test/nil/source/test/nil_test_sequence_006.c

@@ -21,40 +21,62 @@
  * @file    nil_test_sequence_006.c
  * @brief   Test Sequence 006 code.
  *
- * @page nil_test_sequence_006 [6] Synchronous Messages
+ * @page nil_test_sequence_006 [6] Event Sources and Event Flags
  *
  * File: @ref nil_test_sequence_006.c
  *
  * <h2>Description</h2>
- * This module implements the test sequence for the Synchronous
+ * This module implements the test sequence for the Events subsystem.
- * Messages subsystem.
  *
  * <h2>Conditions</h2>
  * This sequence is only executed if the following preprocessor condition
  * evaluates to true:
- * - CH_CFG_USE_MESSAGES
+ * - CH_CFG_USE_EVENTS
  * .
  *
  * <h2>Test Cases</h2>
  * - @subpage nil_test_006_001
+ * - @subpage nil_test_006_002
+ * - @subpage nil_test_006_003
+ * - @subpage nil_test_006_004
+ * - @subpage nil_test_006_005
+ * - @subpage nil_test_006_006
+ * - @subpage nil_test_006_007
  * .
  */
 
-#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
 
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
-/*
+static EVENTSOURCE_DECL(es1);
- * Messager thread.
+static EVENTSOURCE_DECL(es2);
- */
-static THD_FUNCTION(messenger, p) {
 
-  chMsgSend(p, 'A');
+static void h1(eventid_t id) {(void)id;test_emit_token('A');}
-  chMsgSend(p, 'B');
+static void h2(eventid_t id) {(void)id;test_emit_token('B');}
-  chMsgSend(p, 'C');
+static void h3(eventid_t id) {(void)id;test_emit_token('C');}
-  chMsgSend(p, 'D');
+static ROMCONST evhandler_t evhndl[] = {h1, h2, h3};
+
+/*
+ * Direct events thread.
+ */
+static THD_FUNCTION(evtthd1, p) {
+
+  chThdSleepMilliseconds(50);
+  chEvtSignal((thread_t *)p, 1);
+}
+
+/*
+ * Broadcaster thread.
+ */
+static THD_FUNCTION(evtthd2, p) {
+
+  (void)p;
+  chEvtBroadcast(&es1);
+  chThdSleepMilliseconds(50);
+  chEvtBroadcast(&es2);
 }
 
 /****************************************************************************
@@ -62,61 +84,523 @@ static THD_FUNCTION(messenger, p) {
  ****************************************************************************/
 
 /**
- * @page nil_test_006_001 [6.1] Messages Server loop
+ * @page nil_test_006_001 [6.1] Events registration
  *
  * <h2>Description</h2>
- * A messenger thread is spawned that sends four messages back to the
+ * Two event listeners are registered on an event source and then
- * tester thread.<br> The test expect to receive the messages in the
+ * unregistered in the same order.<br> The test expects that the even
- * correct sequence and to not find a fifth message waiting.
+ * source has listeners after the registrations and after the first
+ * unregistration, then, after the second unegistration, the test
+ * expects no more listeners.
  *
  * <h2>Test Steps</h2>
- * - [6.1.1] Starting the messenger thread.
+ * - [6.1.1] An Event Source is initialized.
- * - [6.1.2] Waiting for four messages then testing the receive order.
+ * - [6.1.2] Two Event Listeners are registered on the Event Source,
+ *   the Event Source is tested to have listeners.
+ * - [6.1.3] An Event Listener is unregistered, the Event Source must
+ *   still have listeners.
+ * - [6.1.4] An Event Listener is unregistered, the Event Source must
+ *   not have listeners.
  * .
  */
 
 static void nil_test_006_001_execute(void) {
-  thread_t *tp, *tp1;
+  event_listener_t el1, el2;
-  msg_t msg;
 
-  /* [6.1.1] Starting the messenger thread.*/
+  /* [6.1.1] An Event Source is initialized.*/
   test_set_step(1);
   {
-    thread_descriptor_t td = {
+    chEvtObjectInit(&es1);
-      .name  = "messenger",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() - 1,
-      .funcp = messenger,
-      .arg   = chThdGetSelfX()
-    };
-    tp1 = chThdCreate(&td);
   }
   test_end_step(1);
 
-  /* [6.1.2] Waiting for four messages then testing the receive
+  /* [6.1.2] Two Event Listeners are registered on the Event Source,
-     order.*/
+     the Event Source is tested to have listeners.*/
   test_set_step(2);
   {
-    unsigned i;
+    chEvtRegisterMask(&es1, &el1, 1);
+    chEvtRegisterMask(&es1, &el2, 2);
+    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
+  }
+  test_end_step(2);
 
-    for (i = 0; i < 4; i++) {
+  /* [6.1.3] An Event Listener is unregistered, the Event Source must
-      tp = chMsgWait();
+     still have listeners.*/
-      msg = chMsgGet(tp);
+  test_set_step(3);
-      chMsgRelease(tp, msg);
+  {
-      test_emit_token(msg);
+    chEvtUnregister(&es1, &el1);
-    }
+    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
-    chThdWait(tp1);
+  }
-    test_assert_sequence("ABCD", "invalid sequence");
+  test_end_step(3);
+
+  /* [6.1.4] An Event Listener is unregistered, the Event Source must
+     not have listeners.*/
+  test_set_step(4);
+  {
+    chEvtUnregister(&es1, &el2);
+    test_assert_lock(!chEvtIsListeningI(&es1), "stuck listener");
+  }
+  test_end_step(4);
+}
+
+static const testcase_t nil_test_006_001 = {
+  "Events registration",
+  NULL,
+  NULL,
+  nil_test_006_001_execute
+};
+
+/**
+ * @page nil_test_006_002 [6.2] Event Flags dispatching
+ *
+ * <h2>Description</h2>
+ * The test dispatches three event flags and verifies that the
+ * associated event handlers are invoked in LSb-first order.
+ *
+ * <h2>Test Steps</h2>
+ * - [6.2.1] Three evenf flag bits are raised then chEvtDispatch() is
+ *   invoked, the sequence of handlers calls is tested.
+ * .
+ */
+
+static void nil_test_006_002_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void nil_test_006_002_execute(void) {
+
+  /* [6.2.1] Three evenf flag bits are raised then chEvtDispatch() is
+     invoked, the sequence of handlers calls is tested.*/
+  test_set_step(1);
+  {
+    chEvtDispatch(evhndl, 7);
+    test_assert_sequence("ABC", "invalid sequence");
+  }
+  test_end_step(1);
+}
+
+static const testcase_t nil_test_006_002 = {
+  "Event Flags dispatching",
+  nil_test_006_002_setup,
+  NULL,
+  nil_test_006_002_execute
+};
+
+/**
+ * @page nil_test_006_003 [6.3] Events Flags wait using chEvtWaitOne()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtWaitOne() is tested under various scenarios.
+ *
+ * <h2>Test Steps</h2>
+ * - [6.3.1] Setting three event flags.
+ * - [6.3.2] Calling chEvtWaitOne() three times, each time a single
+ *   flag must be returned in order of priority.
+ * - [6.3.3] Getting current time and starting a signaler thread, the
+ *   thread will set an event flag after 50mS.
+ * - [6.3.4] Calling chEvtWaitOne() then verifying that the event has
+ *   been received after 50mS and that the event flags mask has been
+ *   emptied.
+ * .
+ */
+
+static void nil_test_006_003_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void nil_test_006_003_execute(void) {
+  eventmask_t m;
+  systime_t target_time;
+  thread_t *tp;
+
+  /* [6.3.1] Setting three event flags.*/
+  test_set_step(1);
+  {
+    chEvtAddEvents(7);
+  }
+  test_end_step(1);
+
+  /* [6.3.2] Calling chEvtWaitOne() three times, each time a single
+     flag must be returned in order of priority.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert(m == 1, "single event error");
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert(m == 2, "single event error");
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert(m == 4, "single event error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+  }
+  test_end_step(2);
+
+  /* [6.3.3] Getting current time and starting a signaler thread, the
+     thread will set an event flag after 50mS.*/
+  test_set_step(3);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    thread_descriptor_t td = {
+      .name  = "event1",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() + 1,
+      .funcp = evtthd1,
+      .arg   = chThdGetSelfX()
+    };
+    tp = chThdCreate(&td);
+  }
+  test_end_step(3);
+
+  /* [6.3.4] Calling chEvtWaitOne() then verifying that the event has
+     been received after 50mS and that the event flags mask has been
+     emptied.*/
+  test_set_step(4);
+  {
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    test_assert(m == 1, "event flag error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    chThdWait(tp);
+  }
+  test_end_step(4);
+}
+
+static const testcase_t nil_test_006_003 = {
+  "Events Flags wait using chEvtWaitOne()",
+  nil_test_006_003_setup,
+  NULL,
+  nil_test_006_003_execute
+};
+
+/**
+ * @page nil_test_006_004 [6.4] Events Flags wait using chEvtWaitAny()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtWaitAny() is tested under various scenarios.
+ *
+ * <h2>Test Steps</h2>
+ * - [6.4.1] Setting two, non contiguous, event flags.
+ * - [6.4.2] Calling chEvtWaitAny() one time, the two flags must be
+ *   returned.
+ * - [6.4.3] Getting current time and starting a signaler thread, the
+ *   thread will set an event flag after 50mS.
+ * - [6.4.4] Calling chEvtWaitAny() then verifying that the event has
+ *   been received after 50mS and that the event flags mask has been
+ *   emptied.
+ * .
+ */
+
+static void nil_test_006_004_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void nil_test_006_004_execute(void) {
+  eventmask_t m;
+  systime_t target_time;
+  thread_t *tp;
+
+  /* [6.4.1] Setting two, non contiguous, event flags.*/
+  test_set_step(1);
+  {
+    chEvtAddEvents(5);
+  }
+  test_end_step(1);
+
+  /* [6.4.2] Calling chEvtWaitAny() one time, the two flags must be
+     returned.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitAny(ALL_EVENTS);
+    test_assert(m == 5, "unexpected pending bit");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+  }
+  test_end_step(2);
+
+  /* [6.4.3] Getting current time and starting a signaler thread, the
+     thread will set an event flag after 50mS.*/
+  test_set_step(3);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    thread_descriptor_t td = {
+      .name  = "event1",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() + 1,
+      .funcp = evtthd1,
+      .arg   = chThdGetSelfX()
+    };
+    tp = chThdCreate(&td);
+  }
+  test_end_step(3);
+
+  /* [6.4.4] Calling chEvtWaitAny() then verifying that the event has
+     been received after 50mS and that the event flags mask has been
+     emptied.*/
+  test_set_step(4);
+  {
+    m = chEvtWaitAny(ALL_EVENTS);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    test_assert(m == 1, "event flag error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    chThdWait(tp);
+  }
+  test_end_step(4);
+}
+
+static const testcase_t nil_test_006_004 = {
+  "Events Flags wait using chEvtWaitAny()",
+  nil_test_006_004_setup,
+  NULL,
+  nil_test_006_004_execute
+};
+
+/**
+ * @page nil_test_006_005 [6.5] Events Flags wait using chEvtWaitAll()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtWaitAll() is tested under various scenarios.
+ *
+ * <h2>Test Steps</h2>
+ * - [6.5.1] Setting two, non contiguous, event flags.
+ * - [6.5.2] Calling chEvtWaitAll() one time, the two flags must be
+ *   returned.
+ * - [6.5.3] Setting one event flag.
+ * - [6.5.4] Getting current time and starting a signaler thread, the
+ *   thread will set another event flag after 50mS.
+ * - [6.5.5] Calling chEvtWaitAll() then verifying that both event
+ *   flags have been received after 50mS and that the event flags mask
+ *   has been emptied.
+ * .
+ */
+
+static void nil_test_006_005_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void nil_test_006_005_execute(void) {
+  eventmask_t m;
+  systime_t target_time;
+  thread_t *tp;
+
+  /* [6.5.1] Setting two, non contiguous, event flags.*/
+  test_set_step(1);
+  {
+    chEvtAddEvents(5);
+  }
+  test_end_step(1);
+
+  /* [6.5.2] Calling chEvtWaitAll() one time, the two flags must be
+     returned.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitAll(5);
+    test_assert(m == 5, "unexpected pending bit");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+  }
+  test_end_step(2);
+
+  /* [6.5.3] Setting one event flag.*/
+  test_set_step(3);
+  {
+    chEvtAddEvents(4);
+  }
+  test_end_step(3);
+
+  /* [6.5.4] Getting current time and starting a signaler thread, the
+     thread will set another event flag after 50mS.*/
+  test_set_step(4);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    thread_descriptor_t td = {
+      .name  = "event1",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() + 1,
+      .funcp = evtthd1,
+      .arg   = chThdGetSelfX()
+    };
+    tp = chThdCreate(&td);
+  }
+  test_end_step(4);
+
+  /* [6.5.5] Calling chEvtWaitAll() then verifying that both event
+     flags have been received after 50mS and that the event flags mask
+     has been emptied.*/
+  test_set_step(5);
+  {
+    m = chEvtWaitAll(5);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    test_assert(m == 5, "event flags error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    chThdWait(tp);
+  }
+  test_end_step(5);
+}
+
+static const testcase_t nil_test_006_005 = {
+  "Events Flags wait using chEvtWaitAll()",
+  nil_test_006_005_setup,
+  NULL,
+  nil_test_006_005_execute
+};
+
+/**
+ * @page nil_test_006_006 [6.6] Events Flags wait timeouts
+ *
+ * <h2>Description</h2>
+ * Timeout functionality is tested for chEvtWaitOneTimeout(),
+ * chEvtWaitAnyTimeout() and chEvtWaitAllTimeout().
+ *
+ * <h2>Test Steps</h2>
+ * - [6.6.1] The functions are invoked first with TIME_IMMEDIATE
+ *   timeout, the timeout condition is tested.
+ * - [6.6.2] The functions are invoked first with a 50mS timeout, the
+ *   timeout condition is tested.
+ * .
+ */
+
+static void nil_test_006_006_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void nil_test_006_006_execute(void) {
+  eventmask_t m;
+
+  /* [6.6.1] The functions are invoked first with TIME_IMMEDIATE
+     timeout, the timeout condition is tested.*/
+  test_set_step(1);
+  {
+    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_IMMEDIATE);
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_IMMEDIATE);
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_IMMEDIATE);
+    test_assert(m == 0, "spurious event");
+  }
+  test_end_step(1);
+
+  /* [6.6.2] The functions are invoked first with a 50mS timeout, the
+     timeout condition is tested.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_MS2I(50));
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_MS2I(50));
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_MS2I(50));
+    test_assert(m == 0, "spurious event");
   }
   test_end_step(2);
 }
 
-static const testcase_t nil_test_006_001 = {
+static const testcase_t nil_test_006_006 = {
-  "Messages Server loop",
+  "Events Flags wait timeouts",
+  nil_test_006_006_setup,
   NULL,
+  nil_test_006_006_execute
+};
+
+/**
+ * @page nil_test_006_007 [6.7] Broadcasting using chEvtBroadcast()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtBroadcast() is tested.
+ *
+ * <h2>Test Steps</h2>
+ * - [6.7.1] Registering on two event sources associating them with
+ *   flags 1 and 4.
+ * - [6.7.2] Getting current time and starting a broadcaster thread,
+ *   the thread broadcast the first Event Source immediately and the
+ *   other after 50mS.
+ * - [6.7.3] Calling chEvtWaitAll() then verifying that both event
+ *   flags have been received after 50mS and that the event flags mask
+ *   has been emptied.
+ * - [6.7.4] Unregistering from the Event Sources.
+ * .
+ */
+
+static void nil_test_006_007_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+  chEvtObjectInit(&es1);
+  chEvtObjectInit(&es2);
+}
+
+static void nil_test_006_007_execute(void) {
+  eventmask_t m;
+  event_listener_t el1, el2;
+  systime_t target_time;
+  thread_t *tp;
+
+  /* [6.7.1] Registering on two event sources associating them with
+     flags 1 and 4.*/
+  test_set_step(1);
+  {
+    chEvtRegisterMask(&es1, &el1, 1);
+    chEvtRegisterMask(&es2, &el2, 4);
+  }
+  test_end_step(1);
+
+  /* [6.7.2] Getting current time and starting a broadcaster thread,
+     the thread broadcast the first Event Source immediately and the
+     other after 50mS.*/
+  test_set_step(2);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    thread_descriptor_t td = {
+      .name  = "event2",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() + 1,
+      .funcp = evtthd2,
+      .arg   = NULL
+    };
+    tp = chThdCreate(&td);
+  }
+  test_end_step(2);
+
+  /* [6.7.3] Calling chEvtWaitAll() then verifying that both event
+     flags have been received after 50mS and that the event flags mask
+     has been emptied.*/
+  test_set_step(3);
+  {
+    m = chEvtWaitAll(5);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    chThdWait(tp);
+  }
+  test_end_step(3);
+
+  /* [6.7.4] Unregistering from the Event Sources.*/
+  test_set_step(4);
+  {
+    chEvtUnregister(&es1, &el1);
+    chEvtUnregister(&es2, &el2);
+    test_assert(!chEvtIsListeningI(&es1), "stuck listener");
+    test_assert(!chEvtIsListeningI(&es2), "stuck listener");
+  }
+  test_end_step(4);
+}
+
+static const testcase_t nil_test_006_007 = {
+  "Broadcasting using chEvtBroadcast()",
+  nil_test_006_007_setup,
   NULL,
-  nil_test_006_001_execute
+  nil_test_006_007_execute
 };
 
 /****************************************************************************
@@ -128,15 +612,21 @@ static const testcase_t nil_test_006_001 = {
  */
 const testcase_t * const nil_test_sequence_006_array[] = {
   &nil_test_006_001,
+  &nil_test_006_002,
+  &nil_test_006_003,
+  &nil_test_006_004,
+  &nil_test_006_005,
+  &nil_test_006_006,
+  &nil_test_006_007,
   NULL
 };
 
 /**
- * @brief   Synchronous Messages.
+ * @brief   Event Sources and Event Flags.
  */
 const testsequence_t nil_test_sequence_006 = {
-  "Synchronous Messages",
+  "Event Sources and Event Flags",
   nil_test_sequence_006_array
 };
 
-#endif /* CH_CFG_USE_MESSAGES */
+#endif /* CH_CFG_USE_EVENTS */

test/nil/source/test/nil_test_sequence_007.c

@@ -21,613 +21,103 @@
  * @file    nil_test_sequence_007.c
  * @brief   Test Sequence 007 code.
  *
- * @page nil_test_sequence_007 [7] Benchmarks
+ * @page nil_test_sequence_007 [7] Synchronous Messages
  *
  * File: @ref nil_test_sequence_007.c
  *
  * <h2>Description</h2>
- * This module implements a series of system benchmarks. The benchmarks
+ * This module implements the test sequence for the Synchronous
- * are useful as a stress test and as a reference when comparing
+ * Messages subsystem.
- * ChibiOS/RT with similar systems.<br> Objective of the test sequence
+ *
- * is to provide a performance index for the most critical system
+ * <h2>Conditions</h2>
- * subsystems. The performance numbers allow to discover performance
+ * This sequence is only executed if the following preprocessor condition
- * regressions between successive ChibiOS/RT releases.
+ * evaluates to true:
+ * - CH_CFG_USE_MESSAGES
+ * .
  *
  * <h2>Test Cases</h2>
  * - @subpage nil_test_007_001
- * - @subpage nil_test_007_002
- * - @subpage nil_test_007_003
- * - @subpage nil_test_007_004
- * - @subpage nil_test_007_005
- * - @subpage nil_test_007_006
- * - @subpage nil_test_007_007
  * .
  */
 
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
-#if CH_CFG_USE_SEMAPHORES || defined(__DOXYGEN__)
+/*
-static semaphore_t sem1;
+ * Messager thread.
-#endif
+ */
-#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__)
+static THD_FUNCTION(messenger, p) {
-static mutex_t mtx1;
-#endif
 
-#if CH_CFG_USE_MESSAGES
+  chMsgSend(p, 'A');
-static THD_FUNCTION(bmk_thread1, p) {
+  chMsgSend(p, 'B');
-  thread_t *tp;
+  chMsgSend(p, 'C');
-  msg_t msg;
+  chMsgSend(p, 'D');
-
-  (void)p;
-  do {
-    tp = chMsgWait();
-    msg = chMsgGet(tp);
-    chMsgRelease(tp, msg);
-  } while (msg);
-}
-
-NOINLINE static unsigned int msg_loop_test(thread_t *tp) {
-  systime_t start, end;
-
-  uint32_t n = 0;
-  start = test_wait_tick();
-  end = chTimeAddX(start, TIME_MS2I(1000));
-  do {
-    (void)chMsgSend(tp, 1);
-    n++;
-#if defined(SIMULATOR)
-    _sim_check_for_interrupts();
-#endif
-  } while (chVTIsSystemTimeWithinX(start, end));
-  (void)chMsgSend(tp, 0);
-  return n;
-}
-#endif
-
-static THD_FUNCTION(bmk_thread3, p) {
-
-  chThdExit((msg_t)p);
-}
-
-static THD_FUNCTION(bmk_thread4, p) {
-  msg_t msg;
-  thread_t *self = chThdGetSelfX();
-
-  (void)p;
-  chSysLock();
-  do {
-    chSchGoSleepS(NIL_STATE_SUSPENDED);
-    msg = self->u1.msg;
-  } while (msg == MSG_OK);
-  chSysUnlock();
 }
 
 /****************************************************************************
  * Test cases.
  ****************************************************************************/
 
-#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
 /**
- * @page nil_test_007_001 [7.1] Messages performance #1
+ * @page nil_test_007_001 [7.1] Messages Server loop
  *
  * <h2>Description</h2>
- * A message server thread is created with a lower priority than the
+ * A messenger thread is spawned that sends four messages back to the
- * client thread, the messages throughput per second is measured and
+ * tester thread.<br> The test expect to receive the messages in the
- * the result printed on the output log.
+ * correct sequence and to not find a fifth message waiting.
- *
- * <h2>Conditions</h2>
- * This test is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_MESSAGES
- * .
  *
  * <h2>Test Steps</h2>
- * - [7.1.1] The messenger thread is started at a lower priority than
+ * - [7.1.1] Starting the messenger thread.
- *   the current thread.
+ * - [7.1.2] Waiting for four messages then testing the receive order.
- * - [7.1.2] The number of messages exchanged is counted in a one
- *   second time window.
- * - [7.1.3] Score is printed.
  * .
  */
 
 static void nil_test_007_001_execute(void) {
-  uint32_t n;
+  thread_t *tp, *tp1;
-  thread_t *tp;
+  msg_t msg;
 
-  /* [7.1.1] The messenger thread is started at a lower priority than
+  /* [7.1.1] Starting the messenger thread.*/
-     the current thread.*/
   test_set_step(1);
   {
     thread_descriptor_t td = {
       .name  = "messenger",
       .wbase = wa_common,
       .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() + 1,
+      .prio  = chThdGetPriorityX() - 1,
-      .funcp = bmk_thread1,
+      .funcp = messenger,
-      .arg   = NULL
+      .arg   = chThdGetSelfX()
     };
-    tp = chThdCreate(&td);
+    tp1 = chThdCreate(&td);
   }
   test_end_step(1);
 
-  /* [7.1.2] The number of messages exchanged is counted in a one
+  /* [7.1.2] Waiting for four messages then testing the receive
-     second time window.*/
+     order.*/
   test_set_step(2);
   {
-    n = msg_loop_test(tp);
+    unsigned i;
-    chThdWait(tp);
+
+    for (i = 0; i < 4; i++) {
+      tp = chMsgWait();
+      msg = chMsgGet(tp);
+      chMsgRelease(tp, msg);
+      test_emit_token(msg);
+    }
+    chThdWait(tp1);
+    test_assert_sequence("ABCD", "invalid sequence");
   }
   test_end_step(2);
-
-  /* [7.1.3] Score is printed.*/
-  test_set_step(3);
-  {
-    test_print("--- Score : ");
-    test_printn(n);
-    test_print(" msgs/S, ");
-    test_printn(n << 1);
-    test_println(" ctxswc/S");
-  }
-  test_end_step(3);
 }
 
 static const testcase_t nil_test_007_001 = {
-  "Messages performance #1",
+  "Messages Server loop",
   NULL,
   NULL,
   nil_test_007_001_execute
 };
-#endif /* CH_CFG_USE_MESSAGES */
-
-#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
-/**
- * @page nil_test_007_002 [7.2] Messages performance #2
- *
- * <h2>Description</h2>
- * A message server thread is created with an higher priority than the
- * client thread, the messages throughput per second is measured and
- * the result printed on the output log.
- *
- * <h2>Conditions</h2>
- * This test is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_MESSAGES
- * .
- *
- * <h2>Test Steps</h2>
- * - [7.2.1] The messenger thread is started at an higher priority than
- *   the current thread.
- * - [7.2.2] The number of messages exchanged is counted in a one
- *   second time window.
- * - [7.2.3] Score is printed.
- * .
- */
-
-static void nil_test_007_002_execute(void) {
-  uint32_t n;
-  thread_t *tp;
-
-  /* [7.2.1] The messenger thread is started at an higher priority than
-     the current thread.*/
-  test_set_step(1);
-  {
-    thread_descriptor_t td = {
-      .name  = "messenger",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() - 1,
-      .funcp = bmk_thread1,
-      .arg   = NULL
-    };
-    tp = chThdCreate(&td);
-  }
-  test_end_step(1);
-
-  /* [7.2.2] The number of messages exchanged is counted in a one
-     second time window.*/
-  test_set_step(2);
-  {
-    n = msg_loop_test(tp);
-    chThdWait(tp);
-  }
-  test_end_step(2);
-
-  /* [7.2.3] Score is printed.*/
-  test_set_step(3);
-  {
-    test_print("--- Score : ");
-    test_printn(n);
-    test_print(" msgs/S, ");
-    test_printn(n << 1);
-    test_println(" ctxswc/S");
-  }
-  test_end_step(3);
-}
-
-static const testcase_t nil_test_007_002 = {
-  "Messages performance #2",
-  NULL,
-  NULL,
-  nil_test_007_002_execute
-};
-#endif /* CH_CFG_USE_MESSAGES */
-
-/**
- * @page nil_test_007_003 [7.3] Context Switch performance
- *
- * <h2>Description</h2>
- * A thread is created that just performs a @p chSchGoSleepS() into a
- * loop, the thread is awakened as fast is possible by the tester
- * thread.<br> The Context Switch performance is calculated by
- * measuring the number of iterations after a second of continuous
- * operations.
- *
- * <h2>Test Steps</h2>
- * - [7.3.1] Starting the target thread at an higher priority level.
- * - [7.3.2] Waking up the thread as fast as possible in a one second
- *   time window.
- * - [7.3.3] Stopping the target thread.
- * - [7.3.4] Score is printed.
- * .
- */
-
-static void nil_test_007_003_execute(void) {
-  thread_t *tp;
-  uint32_t n;
-
-  /* [7.3.1] Starting the target thread at an higher priority level.*/
-  test_set_step(1);
-  {
-    thread_descriptor_t td = {
-      .name  = "messenger",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() - 1,
-      .funcp = bmk_thread4,
-      .arg   = NULL
-    };
-    tp = chThdCreate(&td);
-  }
-  test_end_step(1);
-
-  /* [7.3.2] Waking up the thread as fast as possible in a one second
-     time window.*/
-  test_set_step(2);
-  {
-    systime_t start, end;
-
-    n = 0;
-    start = test_wait_tick();
-    end = chTimeAddX(start, TIME_MS2I(1000));
-    do {
-      chSysLock();
-      chSchWakeupS(tp, MSG_OK);
-      chSchWakeupS(tp, MSG_OK);
-      chSchWakeupS(tp, MSG_OK);
-      chSchWakeupS(tp, MSG_OK);
-      chSysUnlock();
-      n += 4;
-    } while (chVTIsSystemTimeWithinX(start, end));
-  }
-  test_end_step(2);
-
-  /* [7.3.3] Stopping the target thread.*/
-  test_set_step(3);
-  {
-    chSysLock();
-    chSchWakeupS(tp, MSG_TIMEOUT);
-    chSysUnlock();
-    chThdWait(tp);
-  }
-  test_end_step(3);
-
-  /* [7.3.4] Score is printed.*/
-  test_set_step(4);
-  {
-    test_print("--- Score : ");
-    test_printn(n * 2);
-    test_println(" ctxswc/S");
-  }
-  test_end_step(4);
-}
-
-static const testcase_t nil_test_007_003 = {
-  "Context Switch performance",
-  NULL,
-  NULL,
-  nil_test_007_003_execute
-};
-
-/**
- * @page nil_test_007_004 [7.4] Threads performance, full cycle
- *
- * <h2>Description</h2>
- * Threads are continuously created and terminated into a loop. A full
- * chThdCreateStatic() / @p chThdExit() / @p chThdWait() cycle is
- * performed in each iteration.<br> The performance is calculated by
- * measuring the number of iterations after a second of continuous
- * operations.
- *
- * <h2>Test Steps</h2>
- * - [7.4.1] A thread is created at a lower priority level and its
- *   termination detected using @p chThdWait(). The operation is
- *   repeated continuously in a one-second time window.
- * - [7.4.2] Score is printed.
- * .
- */
-
-static void nil_test_007_004_execute(void) {
-  uint32_t n;
-
-  /* [7.4.1] A thread is created at a lower priority level and its
-     termination detected using @p chThdWait(). The operation is
-     repeated continuously in a one-second time window.*/
-  test_set_step(1);
-  {
-    systime_t start, end;
-    thread_descriptor_t td = {
-      .name  = "messenger",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() + 1,
-      .funcp = bmk_thread3,
-      .arg   = NULL
-    };
-
-    n = 0;
-    start = test_wait_tick();
-    end = chTimeAddX(start, TIME_MS2I(1000));
-    do {
-      chThdWait(chThdCreate(&td));
-      n++;
-    } while (chVTIsSystemTimeWithinX(start, end));
-  }
-  test_end_step(1);
-
-  /* [7.4.2] Score is printed.*/
-  test_set_step(2);
-  {
-    test_print("--- Score : ");
-    test_printn(n);
-    test_println(" threads/S");
-  }
-  test_end_step(2);
-}
-
-static const testcase_t nil_test_007_004 = {
-  "Threads performance, full cycle",
-  NULL,
-  NULL,
-  nil_test_007_004_execute
-};
-
-/**
- * @page nil_test_007_005 [7.5] Threads performance, create/exit only
- *
- * <h2>Description</h2>
- * Threads are continuously created and terminated into a loop. A
- * partial @p chThdCreateStatic() / @p chThdExit() cycle is performed
- * in each iteration, the @p chThdWait() is not necessary because the
- * thread is created at an higher priority so there is no need to wait
- * for it to terminate.<br> The performance is calculated by measuring
- * the number of iterations after a second of continuous operations.
- *
- * <h2>Test Steps</h2>
- * - [7.5.1] A thread is created at an higher priority level and let
- *   terminate immediately. The operation is repeated continuously in a
- *   one-second time window.
- * - [7.5.2] Score is printed.
- * .
- */
-
-static void nil_test_007_005_execute(void) {
-  uint32_t n;
-
-  /* [7.5.1] A thread is created at an higher priority level and let
-     terminate immediately. The operation is repeated continuously in a
-     one-second time window.*/
-  test_set_step(1);
-  {
-    systime_t start, end;
-    thread_descriptor_t td = {
-      .name  = "messenger",
-      .wbase = wa_common,
-      .wend  = THD_WORKING_AREA_END(wa_common),
-      .prio  = chThdGetPriorityX() - 1,
-      .funcp = bmk_thread3,
-      .arg   = NULL
-    };
-
-    n = 0;
-    start = test_wait_tick();
-    end = chTimeAddX(start, TIME_MS2I(1000));
-    do {
-      chThdWait(chThdCreate(&td));
-      n++;
-    } while (chVTIsSystemTimeWithinX(start, end));
-  }
-  test_end_step(1);
-
-  /* [7.5.2] Score is printed.*/
-  test_set_step(2);
-  {
-    test_print("--- Score : ");
-    test_printn(n);
-    test_println(" threads/S");
-  }
-  test_end_step(2);
-}
-
-static const testcase_t nil_test_007_005 = {
-  "Threads performance, create/exit only",
-  NULL,
-  NULL,
-  nil_test_007_005_execute
-};
-
-#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
-/**
- * @page nil_test_007_006 [7.6] Semaphores wait/signal performance
- *
- * <h2>Description</h2>
- * A counting semaphore is taken/released into a continuous loop, no
- * Context Switch happens because the counter is always non
- * negative.<br> The performance is calculated by measuring the number
- * of iterations after a second of continuous operations.
- *
- * <h2>Conditions</h2>
- * This test is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_SEMAPHORES
- * .
- *
- * <h2>Test Steps</h2>
- * - [7.6.1] A semaphore is teken and released. The operation is
- *   repeated continuously in a one-second time window.
- * - [7.6.2] The score is printed.
- * .
- */
-
-static void nil_test_007_006_setup(void) {
-  chSemObjectInit(&sem1, 1);
-}
-
-static void nil_test_007_006_execute(void) {
-  uint32_t n;
-
-  /* [7.6.1] A semaphore is teken and released. The operation is
-     repeated continuously in a one-second time window.*/
-  test_set_step(1);
-  {
-    systime_t start, end;
-
-    n = 0;
-    start = test_wait_tick();
-    end = chTimeAddX(start, TIME_MS2I(1000));
-    do {
-      chSemWait(&sem1);
-      chSemSignal(&sem1);
-      chSemWait(&sem1);
-      chSemSignal(&sem1);
-      chSemWait(&sem1);
-      chSemSignal(&sem1);
-      chSemWait(&sem1);
-      chSemSignal(&sem1);
-      n++;
-#if defined(SIMULATOR)
-      _sim_check_for_interrupts();
-#endif
-    } while (chVTIsSystemTimeWithinX(start, end));
-  }
-  test_end_step(1);
-
-  /* [7.6.2] The score is printed.*/
-  test_set_step(2);
-  {
-    test_print("--- Score : ");
-    test_printn(n * 4);
-    test_println(" wait+signal/S");
-  }
-  test_end_step(2);
-}
-
-static const testcase_t nil_test_007_006 = {
-  "Semaphores wait/signal performance",
-  nil_test_007_006_setup,
-  NULL,
-  nil_test_007_006_execute
-};
-#endif /* CH_CFG_USE_SEMAPHORES */
-
-/**
- * @page nil_test_007_007 [7.7] RAM Footprint
- *
- * <h2>Description</h2>
- * The memory size of the various kernel objects is printed.
- *
- * <h2>Test Steps</h2>
- * - [7.7.1] The size of the system area is printed.
- * - [7.7.2] The size of a thread structure is printed.
- * - [7.7.3] The size of a semaphore structure is printed.
- * - [7.7.4] The size of an event source is printed.
- * - [7.7.5] The size of an event listener is printed.
- * - [7.7.6] The size of a mailbox is printed.
- * .
- */
-
-static void nil_test_007_007_execute(void) {
-
-  /* [7.7.1] The size of the system area is printed.*/
-  test_set_step(1);
-  {
-    test_print("--- System: ");
-    test_printn(sizeof(nil_system_t));
-    test_println(" bytes");
-  }
-  test_end_step(1);
-
-  /* [7.7.2] The size of a thread structure is printed.*/
-  test_set_step(2);
-  {
-    test_print("--- Thread: ");
-    test_printn(sizeof(thread_t));
-    test_println(" bytes");
-  }
-  test_end_step(2);
-
-  /* [7.7.3] The size of a semaphore structure is printed.*/
-  test_set_step(3);
-  {
-#if CH_CFG_USE_SEMAPHORES || defined(__DOXYGEN__)
-    test_print("--- Semaph: ");
-    test_printn(sizeof(semaphore_t));
-    test_println(" bytes");
-#endif
-  }
-  test_end_step(3);
-
-  /* [7.7.4] The size of an event source is printed.*/
-  test_set_step(4);
-  {
-#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__)
-    test_print("--- EventS: ");
-    test_printn(sizeof(event_source_t));
-    test_println(" bytes");
-#endif
-  }
-  test_end_step(4);
-
-  /* [7.7.5] The size of an event listener is printed.*/
-  test_set_step(5);
-  {
-#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__)
-    test_print("--- EventL: ");
-    test_printn(sizeof(event_listener_t));
-    test_println(" bytes");
-#endif
-  }
-  test_end_step(5);
-
-  /* [7.7.6] The size of a mailbox is printed.*/
-  test_set_step(6);
-  {
-#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
-    test_print("--- MailB.: ");
-    test_printn(sizeof(mailbox_t));
-    test_println(" bytes");
-#endif
-  }
-  test_end_step(6);
-}
-
-static const testcase_t nil_test_007_007 = {
-  "RAM Footprint",
-  NULL,
-  NULL,
-  nil_test_007_007_execute
-};
 
 /****************************************************************************
  * Exported data.
@@ -637,26 +127,16 @@ static const testcase_t nil_test_007_007 = {
  * @brief   Array of test cases.
  */
 const testcase_t * const nil_test_sequence_007_array[] = {
-#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
   &nil_test_007_001,
-#endif
-#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
-  &nil_test_007_002,
-#endif
-  &nil_test_007_003,
-  &nil_test_007_004,
-  &nil_test_007_005,
-#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
-  &nil_test_007_006,
-#endif
-  &nil_test_007_007,
   NULL
 };
 
 /**
- * @brief   Benchmarks.
+ * @brief   Synchronous Messages.
  */
 const testsequence_t nil_test_sequence_007 = {
-  "Benchmarks",
+  "Synchronous Messages",
   nil_test_sequence_007_array
 };
+
+#endif /* CH_CFG_USE_MESSAGES */

test/nil/source/test/nil_test_sequence_008.c

@@ -0,0 +1,662 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 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 "nil_test_root.h"
+
+/**
+ * @file    nil_test_sequence_008.c
+ * @brief   Test Sequence 008 code.
+ *
+ * @page nil_test_sequence_008 [8] Benchmarks
+ *
+ * File: @ref nil_test_sequence_008.c
+ *
+ * <h2>Description</h2>
+ * This module implements a series of system benchmarks. The benchmarks
+ * are useful as a stress test and as a reference when comparing
+ * ChibiOS/RT with similar systems.<br> Objective of the test sequence
+ * is to provide a performance index for the most critical system
+ * subsystems. The performance numbers allow to discover performance
+ * regressions between successive ChibiOS/RT releases.
+ *
+ * <h2>Test Cases</h2>
+ * - @subpage nil_test_008_001
+ * - @subpage nil_test_008_002
+ * - @subpage nil_test_008_003
+ * - @subpage nil_test_008_004
+ * - @subpage nil_test_008_005
+ * - @subpage nil_test_008_006
+ * - @subpage nil_test_008_007
+ * .
+ */
+
+/****************************************************************************
+ * Shared code.
+ ****************************************************************************/
+
+#if CH_CFG_USE_SEMAPHORES || defined(__DOXYGEN__)
+static semaphore_t sem1;
+#endif
+#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__)
+static mutex_t mtx1;
+#endif
+
+#if CH_CFG_USE_MESSAGES
+static THD_FUNCTION(bmk_thread1, p) {
+  thread_t *tp;
+  msg_t msg;
+
+  (void)p;
+  do {
+    tp = chMsgWait();
+    msg = chMsgGet(tp);
+    chMsgRelease(tp, msg);
+  } while (msg);
+}
+
+NOINLINE static unsigned int msg_loop_test(thread_t *tp) {
+  systime_t start, end;
+
+  uint32_t n = 0;
+  start = test_wait_tick();
+  end = chTimeAddX(start, TIME_MS2I(1000));
+  do {
+    (void)chMsgSend(tp, 1);
+    n++;
+#if defined(SIMULATOR)
+    _sim_check_for_interrupts();
+#endif
+  } while (chVTIsSystemTimeWithinX(start, end));
+  (void)chMsgSend(tp, 0);
+  return n;
+}
+#endif
+
+static THD_FUNCTION(bmk_thread3, p) {
+
+  chThdExit((msg_t)p);
+}
+
+static THD_FUNCTION(bmk_thread4, p) {
+  msg_t msg;
+  thread_t *self = chThdGetSelfX();
+
+  (void)p;
+  chSysLock();
+  do {
+    chSchGoSleepS(NIL_STATE_SUSPENDED);
+    msg = self->u1.msg;
+  } while (msg == MSG_OK);
+  chSysUnlock();
+}
+
+/****************************************************************************
+ * Test cases.
+ ****************************************************************************/
+
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+/**
+ * @page nil_test_008_001 [8.1] Messages performance #1
+ *
+ * <h2>Description</h2>
+ * A message server thread is created with a lower priority than the
+ * client thread, the messages throughput per second is measured and
+ * the result printed on the output log.
+ *
+ * <h2>Conditions</h2>
+ * This test is only executed if the following preprocessor condition
+ * evaluates to true:
+ * - CH_CFG_USE_MESSAGES
+ * .
+ *
+ * <h2>Test Steps</h2>
+ * - [8.1.1] The messenger thread is started at a lower priority than
+ *   the current thread.
+ * - [8.1.2] The number of messages exchanged is counted in a one
+ *   second time window.
+ * - [8.1.3] Score is printed.
+ * .
+ */
+
+static void nil_test_008_001_execute(void) {
+  uint32_t n;
+  thread_t *tp;
+
+  /* [8.1.1] The messenger thread is started at a lower priority than
+     the current thread.*/
+  test_set_step(1);
+  {
+    thread_descriptor_t td = {
+      .name  = "messenger",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() + 1,
+      .funcp = bmk_thread1,
+      .arg   = NULL
+    };
+    tp = chThdCreate(&td);
+  }
+  test_end_step(1);
+
+  /* [8.1.2] The number of messages exchanged is counted in a one
+     second time window.*/
+  test_set_step(2);
+  {
+    n = msg_loop_test(tp);
+    chThdWait(tp);
+  }
+  test_end_step(2);
+
+  /* [8.1.3] Score is printed.*/
+  test_set_step(3);
+  {
+    test_print("--- Score : ");
+    test_printn(n);
+    test_print(" msgs/S, ");
+    test_printn(n << 1);
+    test_println(" ctxswc/S");
+  }
+  test_end_step(3);
+}
+
+static const testcase_t nil_test_008_001 = {
+  "Messages performance #1",
+  NULL,
+  NULL,
+  nil_test_008_001_execute
+};
+#endif /* CH_CFG_USE_MESSAGES */
+
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+/**
+ * @page nil_test_008_002 [8.2] Messages performance #2
+ *
+ * <h2>Description</h2>
+ * A message server thread is created with an higher priority than the
+ * client thread, the messages throughput per second is measured and
+ * the result printed on the output log.
+ *
+ * <h2>Conditions</h2>
+ * This test is only executed if the following preprocessor condition
+ * evaluates to true:
+ * - CH_CFG_USE_MESSAGES
+ * .
+ *
+ * <h2>Test Steps</h2>
+ * - [8.2.1] The messenger thread is started at an higher priority than
+ *   the current thread.
+ * - [8.2.2] The number of messages exchanged is counted in a one
+ *   second time window.
+ * - [8.2.3] Score is printed.
+ * .
+ */
+
+static void nil_test_008_002_execute(void) {
+  uint32_t n;
+  thread_t *tp;
+
+  /* [8.2.1] The messenger thread is started at an higher priority than
+     the current thread.*/
+  test_set_step(1);
+  {
+    thread_descriptor_t td = {
+      .name  = "messenger",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() - 1,
+      .funcp = bmk_thread1,
+      .arg   = NULL
+    };
+    tp = chThdCreate(&td);
+  }
+  test_end_step(1);
+
+  /* [8.2.2] The number of messages exchanged is counted in a one
+     second time window.*/
+  test_set_step(2);
+  {
+    n = msg_loop_test(tp);
+    chThdWait(tp);
+  }
+  test_end_step(2);
+
+  /* [8.2.3] Score is printed.*/
+  test_set_step(3);
+  {
+    test_print("--- Score : ");
+    test_printn(n);
+    test_print(" msgs/S, ");
+    test_printn(n << 1);
+    test_println(" ctxswc/S");
+  }
+  test_end_step(3);
+}
+
+static const testcase_t nil_test_008_002 = {
+  "Messages performance #2",
+  NULL,
+  NULL,
+  nil_test_008_002_execute
+};
+#endif /* CH_CFG_USE_MESSAGES */
+
+/**
+ * @page nil_test_008_003 [8.3] Context Switch performance
+ *
+ * <h2>Description</h2>
+ * A thread is created that just performs a @p chSchGoSleepS() into a
+ * loop, the thread is awakened as fast is possible by the tester
+ * thread.<br> The Context Switch performance is calculated by
+ * measuring the number of iterations after a second of continuous
+ * operations.
+ *
+ * <h2>Test Steps</h2>
+ * - [8.3.1] Starting the target thread at an higher priority level.
+ * - [8.3.2] Waking up the thread as fast as possible in a one second
+ *   time window.
+ * - [8.3.3] Stopping the target thread.
+ * - [8.3.4] Score is printed.
+ * .
+ */
+
+static void nil_test_008_003_execute(void) {
+  thread_t *tp;
+  uint32_t n;
+
+  /* [8.3.1] Starting the target thread at an higher priority level.*/
+  test_set_step(1);
+  {
+    thread_descriptor_t td = {
+      .name  = "messenger",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() - 1,
+      .funcp = bmk_thread4,
+      .arg   = NULL
+    };
+    tp = chThdCreate(&td);
+  }
+  test_end_step(1);
+
+  /* [8.3.2] Waking up the thread as fast as possible in a one second
+     time window.*/
+  test_set_step(2);
+  {
+    systime_t start, end;
+
+    n = 0;
+    start = test_wait_tick();
+    end = chTimeAddX(start, TIME_MS2I(1000));
+    do {
+      chSysLock();
+      chSchWakeupS(tp, MSG_OK);
+      chSchWakeupS(tp, MSG_OK);
+      chSchWakeupS(tp, MSG_OK);
+      chSchWakeupS(tp, MSG_OK);
+      chSysUnlock();
+      n += 4;
+    } while (chVTIsSystemTimeWithinX(start, end));
+  }
+  test_end_step(2);
+
+  /* [8.3.3] Stopping the target thread.*/
+  test_set_step(3);
+  {
+    chSysLock();
+    chSchWakeupS(tp, MSG_TIMEOUT);
+    chSysUnlock();
+    chThdWait(tp);
+  }
+  test_end_step(3);
+
+  /* [8.3.4] Score is printed.*/
+  test_set_step(4);
+  {
+    test_print("--- Score : ");
+    test_printn(n * 2);
+    test_println(" ctxswc/S");
+  }
+  test_end_step(4);
+}
+
+static const testcase_t nil_test_008_003 = {
+  "Context Switch performance",
+  NULL,
+  NULL,
+  nil_test_008_003_execute
+};
+
+/**
+ * @page nil_test_008_004 [8.4] Threads performance, full cycle
+ *
+ * <h2>Description</h2>
+ * Threads are continuously created and terminated into a loop. A full
+ * chThdCreateStatic() / @p chThdExit() / @p chThdWait() cycle is
+ * performed in each iteration.<br> The performance is calculated by
+ * measuring the number of iterations after a second of continuous
+ * operations.
+ *
+ * <h2>Test Steps</h2>
+ * - [8.4.1] A thread is created at a lower priority level and its
+ *   termination detected using @p chThdWait(). The operation is
+ *   repeated continuously in a one-second time window.
+ * - [8.4.2] Score is printed.
+ * .
+ */
+
+static void nil_test_008_004_execute(void) {
+  uint32_t n;
+
+  /* [8.4.1] A thread is created at a lower priority level and its
+     termination detected using @p chThdWait(). The operation is
+     repeated continuously in a one-second time window.*/
+  test_set_step(1);
+  {
+    systime_t start, end;
+    thread_descriptor_t td = {
+      .name  = "messenger",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() + 1,
+      .funcp = bmk_thread3,
+      .arg   = NULL
+    };
+
+    n = 0;
+    start = test_wait_tick();
+    end = chTimeAddX(start, TIME_MS2I(1000));
+    do {
+      chThdWait(chThdCreate(&td));
+      n++;
+    } while (chVTIsSystemTimeWithinX(start, end));
+  }
+  test_end_step(1);
+
+  /* [8.4.2] Score is printed.*/
+  test_set_step(2);
+  {
+    test_print("--- Score : ");
+    test_printn(n);
+    test_println(" threads/S");
+  }
+  test_end_step(2);
+}
+
+static const testcase_t nil_test_008_004 = {
+  "Threads performance, full cycle",
+  NULL,
+  NULL,
+  nil_test_008_004_execute
+};
+
+/**
+ * @page nil_test_008_005 [8.5] Threads performance, create/exit only
+ *
+ * <h2>Description</h2>
+ * Threads are continuously created and terminated into a loop. A
+ * partial @p chThdCreateStatic() / @p chThdExit() cycle is performed
+ * in each iteration, the @p chThdWait() is not necessary because the
+ * thread is created at an higher priority so there is no need to wait
+ * for it to terminate.<br> The performance is calculated by measuring
+ * the number of iterations after a second of continuous operations.
+ *
+ * <h2>Test Steps</h2>
+ * - [8.5.1] A thread is created at an higher priority level and let
+ *   terminate immediately. The operation is repeated continuously in a
+ *   one-second time window.
+ * - [8.5.2] Score is printed.
+ * .
+ */
+
+static void nil_test_008_005_execute(void) {
+  uint32_t n;
+
+  /* [8.5.1] A thread is created at an higher priority level and let
+     terminate immediately. The operation is repeated continuously in a
+     one-second time window.*/
+  test_set_step(1);
+  {
+    systime_t start, end;
+    thread_descriptor_t td = {
+      .name  = "messenger",
+      .wbase = wa_common,
+      .wend  = THD_WORKING_AREA_END(wa_common),
+      .prio  = chThdGetPriorityX() - 1,
+      .funcp = bmk_thread3,
+      .arg   = NULL
+    };
+
+    n = 0;
+    start = test_wait_tick();
+    end = chTimeAddX(start, TIME_MS2I(1000));
+    do {
+      chThdWait(chThdCreate(&td));
+      n++;
+    } while (chVTIsSystemTimeWithinX(start, end));
+  }
+  test_end_step(1);
+
+  /* [8.5.2] Score is printed.*/
+  test_set_step(2);
+  {
+    test_print("--- Score : ");
+    test_printn(n);
+    test_println(" threads/S");
+  }
+  test_end_step(2);
+}
+
+static const testcase_t nil_test_008_005 = {
+  "Threads performance, create/exit only",
+  NULL,
+  NULL,
+  nil_test_008_005_execute
+};
+
+#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
+/**
+ * @page nil_test_008_006 [8.6] Semaphores wait/signal performance
+ *
+ * <h2>Description</h2>
+ * A counting semaphore is taken/released into a continuous loop, no
+ * Context Switch happens because the counter is always non
+ * negative.<br> The performance is calculated by measuring the number
+ * of iterations after a second of continuous operations.
+ *
+ * <h2>Conditions</h2>
+ * This test is only executed if the following preprocessor condition
+ * evaluates to true:
+ * - CH_CFG_USE_SEMAPHORES
+ * .
+ *
+ * <h2>Test Steps</h2>
+ * - [8.6.1] A semaphore is teken and released. The operation is
+ *   repeated continuously in a one-second time window.
+ * - [8.6.2] The score is printed.
+ * .
+ */
+
+static void nil_test_008_006_setup(void) {
+  chSemObjectInit(&sem1, 1);
+}
+
+static void nil_test_008_006_execute(void) {
+  uint32_t n;
+
+  /* [8.6.1] A semaphore is teken and released. The operation is
+     repeated continuously in a one-second time window.*/
+  test_set_step(1);
+  {
+    systime_t start, end;
+
+    n = 0;
+    start = test_wait_tick();
+    end = chTimeAddX(start, TIME_MS2I(1000));
+    do {
+      chSemWait(&sem1);
+      chSemSignal(&sem1);
+      chSemWait(&sem1);
+      chSemSignal(&sem1);
+      chSemWait(&sem1);
+      chSemSignal(&sem1);
+      chSemWait(&sem1);
+      chSemSignal(&sem1);
+      n++;
+#if defined(SIMULATOR)
+      _sim_check_for_interrupts();
+#endif
+    } while (chVTIsSystemTimeWithinX(start, end));
+  }
+  test_end_step(1);
+
+  /* [8.6.2] The score is printed.*/
+  test_set_step(2);
+  {
+    test_print("--- Score : ");
+    test_printn(n * 4);
+    test_println(" wait+signal/S");
+  }
+  test_end_step(2);
+}
+
+static const testcase_t nil_test_008_006 = {
+  "Semaphores wait/signal performance",
+  nil_test_008_006_setup,
+  NULL,
+  nil_test_008_006_execute
+};
+#endif /* CH_CFG_USE_SEMAPHORES */
+
+/**
+ * @page nil_test_008_007 [8.7] RAM Footprint
+ *
+ * <h2>Description</h2>
+ * The memory size of the various kernel objects is printed.
+ *
+ * <h2>Test Steps</h2>
+ * - [8.7.1] The size of the system area is printed.
+ * - [8.7.2] The size of a thread structure is printed.
+ * - [8.7.3] The size of a semaphore structure is printed.
+ * - [8.7.4] The size of an event source is printed.
+ * - [8.7.5] The size of an event listener is printed.
+ * - [8.7.6] The size of a mailbox is printed.
+ * .
+ */
+
+static void nil_test_008_007_execute(void) {
+
+  /* [8.7.1] The size of the system area is printed.*/
+  test_set_step(1);
+  {
+    test_print("--- System: ");
+    test_printn(sizeof(nil_system_t));
+    test_println(" bytes");
+  }
+  test_end_step(1);
+
+  /* [8.7.2] The size of a thread structure is printed.*/
+  test_set_step(2);
+  {
+    test_print("--- Thread: ");
+    test_printn(sizeof(thread_t));
+    test_println(" bytes");
+  }
+  test_end_step(2);
+
+  /* [8.7.3] The size of a semaphore structure is printed.*/
+  test_set_step(3);
+  {
+#if CH_CFG_USE_SEMAPHORES || defined(__DOXYGEN__)
+    test_print("--- Semaph: ");
+    test_printn(sizeof(semaphore_t));
+    test_println(" bytes");
+#endif
+  }
+  test_end_step(3);
+
+  /* [8.7.4] The size of an event source is printed.*/
+  test_set_step(4);
+  {
+#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__)
+    test_print("--- EventS: ");
+    test_printn(sizeof(event_source_t));
+    test_println(" bytes");
+#endif
+  }
+  test_end_step(4);
+
+  /* [8.7.5] The size of an event listener is printed.*/
+  test_set_step(5);
+  {
+#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__)
+    test_print("--- EventL: ");
+    test_printn(sizeof(event_listener_t));
+    test_println(" bytes");
+#endif
+  }
+  test_end_step(5);
+
+  /* [8.7.6] The size of a mailbox is printed.*/
+  test_set_step(6);
+  {
+#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__)
+    test_print("--- MailB.: ");
+    test_printn(sizeof(mailbox_t));
+    test_println(" bytes");
+#endif
+  }
+  test_end_step(6);
+}
+
+static const testcase_t nil_test_008_007 = {
+  "RAM Footprint",
+  NULL,
+  NULL,
+  nil_test_008_007_execute
+};
+
+/****************************************************************************
+ * Exported data.
+ ****************************************************************************/
+
+/**
+ * @brief   Array of test cases.
+ */
+const testcase_t * const nil_test_sequence_008_array[] = {
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+  &nil_test_008_001,
+#endif
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+  &nil_test_008_002,
+#endif
+  &nil_test_008_003,
+  &nil_test_008_004,
+  &nil_test_008_005,
+#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
+  &nil_test_008_006,
+#endif
+  &nil_test_008_007,
+  NULL
+};
+
+/**
+ * @brief   Benchmarks.
+ */
+const testsequence_t nil_test_sequence_008 = {
+  "Benchmarks",
+  nil_test_sequence_008_array
+};

test/nil/source/test/nil_test_sequence_008.h

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

test/rt/configuration.xml

@@ -637,6 +637,25 @@ chSysEnable();]]></value>
                   </step>
                 </steps>
               </case>
+            </cases>
+          </sequence>
+          <sequence>
+            <type index="0">
+              <value>Internal Tests</value>
+            </type>
+            <brief>
+              <value>Time and Intervals Functionality.</value>
+            </brief>
+            <description>
+              <value>This sequence tests the ChibiOS/NIL functionalities related to time and intervals management.</value>
+            </description>
+            <condition>
+              <value />
+            </condition>
+            <shared_code>
+              <value><![CDATA[#include "ch.h"]]></value>
+            </shared_code>
+            <cases>
               <case>
                 <brief>
                   <value>System Tick Counter functionality.</value>
@@ -667,16 +686,103 @@ chSysEnable();]]></value>
                       <value />
                     </tags>
                     <code>
-                      <value><![CDATA[systime_t time = chVTGetSystemTimeX();
+                      <value><![CDATA[systime_t time = chVTGetSystemTimeX();
-while (time == chVTGetSystemTimeX()) {
+while (time == chVTGetSystemTimeX()) {
-#if defined(SIMULATOR)
-  _sim_check_for_interrupts();
-#endif
 }]]></value>
                     </code>
                   </step>
                 </steps>
               </case>
+              <case>
+                <brief>
+                  <value>Time ranges functionality.</value>
+                </brief>
+                <description>
+                  <value>The functionality of the API @p chTimeIsInRangeX() is tested.</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value />
+                  </setup_code>
+                  <teardown_code>
+                    <value />
+                  </teardown_code>
+                  <local_variables>
+                    <value />
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>Checking case where start == end, it must always evaluate as in range.</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+bool b;
+
+b = chTimeIsInRangeX((systime_t)0, (systime_t)0, (systime_t)0);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)-1, (systime_t)0, (systime_t)0);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)0, (systime_t)-1, (systime_t)-1);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)-1, (systime_t)-1, (systime_t)-1);
+test_assert(b == true, "not in range");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Checking boundaries for start &lt; end.</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+bool b;
+
+b = chTimeIsInRangeX((systime_t)10, (systime_t)10, (systime_t)100);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)9, (systime_t)10, (systime_t)100);
+test_assert(b == false, "in range");
+b = chTimeIsInRangeX((systime_t)99, (systime_t)10, (systime_t)100);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)100, (systime_t)10, (systime_t)100);
+test_assert(b == false, "in range");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Checking boundaries for start &gt; end.</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+bool b;
+
+b = chTimeIsInRangeX((systime_t)100, (systime_t)100, (systime_t)10);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)99, (systime_t)100, (systime_t)10);
+test_assert(b == false, "in range");
+b = chTimeIsInRangeX((systime_t)9, (systime_t)100, (systime_t)10);
+test_assert(b == true, "not in range");
+b = chTimeIsInRangeX((systime_t)10, (systime_t)100, (systime_t)10);
+test_assert(b == false, "in range");
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
             </cases>
           </sequence>
           <sequence>

test/rt/rt_test.mk

@@ -9,7 +9,8 @@ TESTSRC += ${CHIBIOS}/test/rt/source/test/rt_test_root.c \
            ${CHIBIOS}/test/rt/source/test/rt_test_sequence_007.c \
            ${CHIBIOS}/test/rt/source/test/rt_test_sequence_008.c \
            ${CHIBIOS}/test/rt/source/test/rt_test_sequence_009.c \
-           ${CHIBIOS}/test/rt/source/test/rt_test_sequence_010.c
+           ${CHIBIOS}/test/rt/source/test/rt_test_sequence_010.c \
+           ${CHIBIOS}/test/rt/source/test/rt_test_sequence_011.c
 
 # Required include directories
 TESTINC += ${CHIBIOS}/test/rt/source/test

test/rt/source/test/rt_test_root.c

@@ -31,6 +31,7 @@
  * - @subpage rt_test_sequence_008
  * - @subpage rt_test_sequence_009
  * - @subpage rt_test_sequence_010
+ * - @subpage rt_test_sequence_011
  * .
  */
 
@@ -56,22 +57,23 @@ const testsequence_t * const rt_test_suite_array[] = {
   &rt_test_sequence_002,
   &rt_test_sequence_003,
   &rt_test_sequence_004,
-#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
   &rt_test_sequence_005,
-#endif
+#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
-#if (CH_CFG_USE_MUTEXES) || defined(__DOXYGEN__)
   &rt_test_sequence_006,
 #endif
-#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MUTEXES) || defined(__DOXYGEN__)
   &rt_test_sequence_007,
 #endif
-#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
   &rt_test_sequence_008,
 #endif
-#if (CH_CFG_USE_DYNAMIC) || defined(__DOXYGEN__)
+#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
   &rt_test_sequence_009,
 #endif
+#if (CH_CFG_USE_DYNAMIC) || defined(__DOXYGEN__)
   &rt_test_sequence_010,
+#endif
+  &rt_test_sequence_011,
   NULL
 };
 

test/rt/source/test/rt_test_root.h

@@ -34,6 +34,7 @@
 #include "rt_test_sequence_008.h"
 #include "rt_test_sequence_009.h"
 #include "rt_test_sequence_010.h"
+#include "rt_test_sequence_011.h"
 
 #if !defined(__DOXYGEN__)
 

test/rt/source/test/rt_test_sequence_001.c

@@ -94,6 +94,7 @@ static void rt_test_001_001_execute(void) {
     test_println("");
 #endif
   }
+  test_end_step(1);
 }
 
 static const testcase_t rt_test_001_001 = {
@@ -135,6 +136,7 @@ static void rt_test_001_002_execute(void) {
     test_printn(CH_KERNEL_PATCH);
     test_println("");
   }
+  test_end_step(1);
 }
 
 static const testcase_t rt_test_001_002 = {
@@ -257,6 +259,7 @@ static void rt_test_001_003_execute(void) {
     test_printn(CH_DBG_THREADS_PROFILING);
     test_println("");
   }
+  test_end_step(1);
 }
 
 static const testcase_t rt_test_001_003 = {

test/rt/source/test/rt_test_sequence_002.c

@@ -36,7 +36,6 @@
  * - @subpage rt_test_002_001
  * - @subpage rt_test_002_002
  * - @subpage rt_test_002_003
- * - @subpage rt_test_002_004
  * .
  */
 
@@ -91,6 +90,7 @@ static void rt_test_002_001_execute(void) {
     chSysUnlock();
     test_assert(result == false, "ready list check failed");
   }
+  test_end_step(1);
 
   /* [2.1.2] Testing Virtual Timers List integrity.*/
   test_set_step(2);
@@ -100,6 +100,7 @@ static void rt_test_002_001_execute(void) {
     chSysUnlock();
     test_assert(result == false, "virtual timers list check failed");
   }
+  test_end_step(2);
 
   /* [2.1.3] Testing Registry List integrity.*/
   test_set_step(3);
@@ -109,6 +110,7 @@ static void rt_test_002_001_execute(void) {
     chSysUnlock();
     test_assert(result == false, "registry list check failed");
   }
+  test_end_step(3);
 
   /* [2.1.4] Testing Port-defined integrity.*/
   test_set_step(4);
@@ -118,6 +120,7 @@ static void rt_test_002_001_execute(void) {
     chSysUnlock();
     test_assert(result == false, "port layer check failed");
   }
+  test_end_step(4);
 }
 
 static const testcase_t rt_test_002_001 = {
@@ -155,6 +158,7 @@ static void rt_test_002_002_execute(void) {
     sts = chSysGetStatusAndLockX();
     chSysRestoreStatusX(sts);
   }
+  test_end_step(1);
 
   /* [2.2.2] Testing chSysGetStatusAndLockX() and
      chSysRestoreStatusX(), reentrant case.*/
@@ -165,6 +169,7 @@ static void rt_test_002_002_execute(void) {
     chSysRestoreStatusX(sts);
     chSysUnlock();
   }
+  test_end_step(2);
 
   /* [2.2.3] Testing chSysUnconditionalLock().*/
   test_set_step(3);
@@ -173,6 +178,7 @@ static void rt_test_002_002_execute(void) {
     chSysUnconditionalLock();
     chSysUnlock();
   }
+  test_end_step(3);
 
   /* [2.2.4] Testing chSysUnconditionalUnlock().*/
   test_set_step(4);
@@ -181,6 +187,7 @@ static void rt_test_002_002_execute(void) {
     chSysUnconditionalUnlock();
     chSysUnconditionalUnlock();
   }
+  test_end_step(4);
 
   /* [2.2.5] Testing from ISR context using a virtual timer.*/
   test_set_step(5);
@@ -191,6 +198,7 @@ static void rt_test_002_002_execute(void) {
 
     test_assert(chVTIsArmed(&vt) == false, "timer still armed");
   }
+  test_end_step(5);
 }
 
 static const testcase_t rt_test_002_002 = {
@@ -222,6 +230,7 @@ static void rt_test_002_003_execute(void) {
     chSysSuspend();
     chSysEnable();
   }
+  test_end_step(1);
 }
 
 static const testcase_t rt_test_002_003 = {
@@ -231,40 +240,6 @@ static const testcase_t rt_test_002_003 = {
   rt_test_002_003_execute
 };
 
-/**
- * @page rt_test_002_004 [2.4] System Tick Counter functionality
- *
- * <h2>Description</h2>
- * The functionality of the API @p chVTGetSystemTimeX() is tested.
- *
- * <h2>Test Steps</h2>
- * - [2.4.1] A System Tick Counter increment is expected, the test
- *   simply hangs if it does not happen.
- * .
- */
-
-static void rt_test_002_004_execute(void) {
-
-  /* [2.4.1] A System Tick Counter increment is expected, the test
-     simply hangs if it does not happen.*/
-  test_set_step(1);
-  {
-    systime_t time = chVTGetSystemTimeX();
-    while (time == chVTGetSystemTimeX()) {
-#if defined(SIMULATOR)
-      _sim_check_for_interrupts();
-#endif
-    }
-  }
-}
-
-static const testcase_t rt_test_002_004 = {
-  "System Tick Counter functionality",
-  NULL,
-  NULL,
-  rt_test_002_004_execute
-};
-
 /****************************************************************************
  * Exported data.
  ****************************************************************************/
@@ -276,7 +251,6 @@ const testcase_t * const rt_test_sequence_002_array[] = {
   &rt_test_002_001,
   &rt_test_002_002,
   &rt_test_002_003,
-  &rt_test_002_004,
   NULL
 };
 

test/rt/source/test/rt_test_sequence_003.c

@@ -21,19 +21,17 @@
  * @file    rt_test_sequence_003.c
  * @brief   Test Sequence 003 code.
  *
- * @page rt_test_sequence_003 [3] Threads Functionality
+ * @page rt_test_sequence_003 [3] Time and Intervals Functionality
  *
  * File: @ref rt_test_sequence_003.c
  *
  * <h2>Description</h2>
- * This sequence tests the ChibiOS/RT functionalities related to
+ * This sequence tests the ChibiOS/NIL functionalities related to time
- * threading.
+ * and intervals management.
  *
  * <h2>Test Cases</h2>
  * - @subpage rt_test_003_001
  * - @subpage rt_test_003_002
- * - @subpage rt_test_003_003
- * - @subpage rt_test_003_004
  * .
  */
 
@@ -41,290 +39,117 @@
  * Shared code.
  ****************************************************************************/
 
-static THD_FUNCTION(thread, p) {
+#include "ch.h"
-
-  test_emit_token(*(char *)p);
-}
 
 /****************************************************************************
  * Test cases.
  ****************************************************************************/
 
 /**
- * @page rt_test_003_001 [3.1] Thread Sleep functionality
+ * @page rt_test_003_001 [3.1] System Tick Counter functionality
  *
  * <h2>Description</h2>
- * The functionality of @p chThdSleep() and derivatives is tested.
+ * The functionality of the API @p chVTGetSystemTimeX() is tested.
  *
  * <h2>Test Steps</h2>
- * - [3.1.1] The current system time is read then a sleep is performed
+ * - [3.1.1] A System Tick Counter increment is expected, the test
- *   for 100 system ticks and on exit the system time is verified
+ *   simply hangs if it does not happen.
- *   again.
- * - [3.1.2] The current system time is read then a sleep is performed
- *   for 100000 microseconds and on exit the system time is verified
- *   again.
- * - [3.1.3] The current system time is read then a sleep is performed
- *   for 100 milliseconds and on exit the system time is verified
- *   again.
- * - [3.1.4] The current system time is read then a sleep is performed
- *   for 1 second and on exit the system time is verified again.
- * - [3.1.5] Function chThdSleepUntil() is tested with a timeline of
- *   "now" + 100 ticks.
  * .
  */
 
 static void rt_test_003_001_execute(void) {
-  systime_t time;
 
-  /* [3.1.1] The current system time is read then a sleep is performed
+  /* [3.1.1] A System Tick Counter increment is expected, the test
-     for 100 system ticks and on exit the system time is verified
+     simply hangs if it does not happen.*/
-     again.*/
   test_set_step(1);
   {
-    time = chVTGetSystemTimeX();
+    systime_t time = chVTGetSystemTimeX();
-    chThdSleep(100);
+    while (time == chVTGetSystemTimeX()) {
-    test_assert_time_window(chTimeAddX(time, 100),
+    }
-                            chTimeAddX(time, 100 + CH_CFG_ST_TIMEDELTA + 1),
-                            "out of time window");
-  }
-
-  /* [3.1.2] The current system time is read then a sleep is performed
-     for 100000 microseconds and on exit the system time is verified
-     again.*/
-  test_set_step(2);
-  {
-    time = chVTGetSystemTimeX();
-    chThdSleepMicroseconds(100000);
-    test_assert_time_window(chTimeAddX(time, TIME_US2I(100000)),
-                            chTimeAddX(time, TIME_US2I(100000) + CH_CFG_ST_TIMEDELTA + 1),
-                            "out of time window");
-  }
-
-  /* [3.1.3] The current system time is read then a sleep is performed
-     for 100 milliseconds and on exit the system time is verified
-     again.*/
-  test_set_step(3);
-  {
-    time = chVTGetSystemTimeX();
-    chThdSleepMilliseconds(100);
-    test_assert_time_window(chTimeAddX(time, TIME_MS2I(100)),
-                            chTimeAddX(time, TIME_MS2I(100) + CH_CFG_ST_TIMEDELTA + 1),
-                            "out of time window");
-  }
-
-  /* [3.1.4] The current system time is read then a sleep is performed
-     for 1 second and on exit the system time is verified again.*/
-  test_set_step(4);
-  {
-    time = chVTGetSystemTimeX();
-    chThdSleepSeconds(1);
-    test_assert_time_window(chTimeAddX(time, TIME_S2I(1)),
-                            chTimeAddX(time, TIME_S2I(1) + CH_CFG_ST_TIMEDELTA + 1),
-                            "out of time window");
-  }
-
-  /* [3.1.5] Function chThdSleepUntil() is tested with a timeline of
-     "now" + 100 ticks.*/
-  test_set_step(5);
-  {
-    time = chVTGetSystemTimeX();
-    chThdSleepUntil(chTimeAddX(time, 100));
-    test_assert_time_window(chTimeAddX(time, 100),
-                            chTimeAddX(time, 100 + CH_CFG_ST_TIMEDELTA + 1),
-                            "out of time window");
   }
+  test_end_step(1);
 }
 
 static const testcase_t rt_test_003_001 = {
-  "Thread Sleep functionality",
+  "System Tick Counter functionality",
   NULL,
   NULL,
   rt_test_003_001_execute
 };
 
 /**
- * @page rt_test_003_002 [3.2] Ready List functionality, threads priority order
+ * @page rt_test_003_002 [3.2] Time ranges functionality
  *
  * <h2>Description</h2>
- * Five threads, are enqueued in the ready list and atomically
+ * The functionality of the API @p chTimeIsInRangeX() is tested.
- * executed. The test expects the threads to perform their operations
- * in correct priority order regardless of the initial order.
  *
  * <h2>Test Steps</h2>
- * - [3.2.1] Creating 5 threads with increasing priority, execution
+ * - [3.2.1] Checking case where start == end, it must always evaluate
- *   sequence is tested.
+ *   as in range.
- * - [3.2.2] Creating 5 threads with decreasing priority, execution
+ * - [3.2.2] Checking boundaries for start < end.
- *   sequence is tested.
+ * - [3.2.3] Checking boundaries for start > end.
- * - [3.2.3] Creating 5 threads with pseudo-random priority, execution
- *   sequence is tested.
  * .
  */
 
 static void rt_test_003_002_execute(void) {
 
-  /* [3.2.1] Creating 5 threads with increasing priority, execution
+  /* [3.2.1] Checking case where start == end, it must always evaluate
-     sequence is tested.*/
+     as in range.*/
   test_set_step(1);
   {
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
+    bool b;
-    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
-    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
-    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
-    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
-    test_wait_threads();
-    test_assert_sequence("ABCDE", "invalid sequence");
-  }
 
-  /* [3.2.2] Creating 5 threads with decreasing priority, execution
+    b = chTimeIsInRangeX((systime_t)0, (systime_t)0, (systime_t)0);
-     sequence is tested.*/
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)-1, (systime_t)0, (systime_t)0);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)0, (systime_t)-1, (systime_t)-1);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)-1, (systime_t)-1, (systime_t)-1);
+    test_assert(b == true, "not in range");
+  }
+  test_end_step(1);
+
+  /* [3.2.2] Checking boundaries for start < end.*/
   test_set_step(2);
   {
-    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
+    bool b;
-    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
-    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
-    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
-    test_wait_threads();
-    test_assert_sequence("ABCDE", "invalid sequence");
-  }
 
-  /* [3.2.3] Creating 5 threads with pseudo-random priority, execution
+    b = chTimeIsInRangeX((systime_t)10, (systime_t)10, (systime_t)100);
-     sequence is tested.*/
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)9, (systime_t)10, (systime_t)100);
+    test_assert(b == false, "in range");
+    b = chTimeIsInRangeX((systime_t)99, (systime_t)10, (systime_t)100);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)100, (systime_t)10, (systime_t)100);
+    test_assert(b == false, "in range");
+  }
+  test_end_step(2);
+
+  /* [3.2.3] Checking boundaries for start > end.*/
   test_set_step(3);
   {
-    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
+    bool b;
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
+
-    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
+    b = chTimeIsInRangeX((systime_t)100, (systime_t)100, (systime_t)10);
-    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
+    test_assert(b == true, "not in range");
-    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
+    b = chTimeIsInRangeX((systime_t)99, (systime_t)100, (systime_t)10);
-    test_wait_threads();
+    test_assert(b == false, "in range");
-    test_assert_sequence("ABCDE", "invalid sequence");
+    b = chTimeIsInRangeX((systime_t)9, (systime_t)100, (systime_t)10);
+    test_assert(b == true, "not in range");
+    b = chTimeIsInRangeX((systime_t)10, (systime_t)100, (systime_t)10);
+    test_assert(b == false, "in range");
   }
+  test_end_step(3);
 }
 
 static const testcase_t rt_test_003_002 = {
-  "Ready List functionality, threads priority order",
+  "Time ranges functionality",
   NULL,
   NULL,
   rt_test_003_002_execute
 };
 
-/**
- * @page rt_test_003_003 [3.3] Priority change test
- *
- * <h2>Description</h2>
- * A series of priority changes are performed on the current thread in
- * order to verify that the priority change happens as expected.
- *
- * <h2>Test Steps</h2>
- * - [3.3.1] Thread priority is increased by one then a check is
- *   performed.
- * - [3.3.2] Thread priority is returned to the previous value then a
- *   check is performed.
- * .
- */
-
-static void rt_test_003_003_execute(void) {
-  tprio_t prio, p1;
-
-  /* [3.3.1] Thread priority is increased by one then a check is
-     performed.*/
-  test_set_step(1);
-  {
-    prio = chThdGetPriorityX();
-    p1 = chThdSetPriority(prio + 1);
-    test_assert(p1 == prio, "unexpected returned priority level");
-    test_assert(chThdGetPriorityX() == prio + 1, "unexpected priority level");
-  }
-
-  /* [3.3.2] Thread priority is returned to the previous value then a
-     check is performed.*/
-  test_set_step(2);
-  {
-    p1 = chThdSetPriority(p1);
-    test_assert(p1 == prio + 1, "unexpected returned priority level");
-    test_assert(chThdGetPriorityX() == prio, "unexpected priority level");
-  }
-}
-
-static const testcase_t rt_test_003_003 = {
-  "Priority change test",
-  NULL,
-  NULL,
-  rt_test_003_003_execute
-};
-
-#if (CH_CFG_USE_MUTEXES) || defined(__DOXYGEN__)
-/**
- * @page rt_test_003_004 [3.4] Priority change test with Priority Inheritance
- *
- * <h2>Description</h2>
- * A series of priority changes are performed on the current thread in
- * order to verify that the priority change happens as expected.
- *
- * <h2>Conditions</h2>
- * This test is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_MUTEXES
- * .
- *
- * <h2>Test Steps</h2>
- * - [3.4.1] Simulating a priority boost situation (prio > realprio).
- * - [3.4.2] Raising thread priority above original priority but below
- *   the boosted level.
- * - [3.4.3] Raising thread priority above the boosted level.
- * - [3.4.4] Restoring original conditions.
- * .
- */
-
-static void rt_test_003_004_execute(void) {
-  tprio_t prio, p1;
-
-  /* [3.4.1] Simulating a priority boost situation (prio > realprio).*/
-  test_set_step(1);
-  {
-    prio = chThdGetPriorityX();
-    chThdGetSelfX()->prio += 2;
-    test_assert(chThdGetPriorityX() == prio + 2, "unexpected priority level");
-  }
-
-  /* [3.4.2] Raising thread priority above original priority but below
-     the boosted level.*/
-  test_set_step(2);
-  {
-    p1 = chThdSetPriority(prio + 1);
-    test_assert(p1 == prio, "unexpected returned priority level");
-    test_assert(chThdGetSelfX()->prio == prio + 2, "unexpected priority level");
-    test_assert(chThdGetSelfX()->realprio == prio + 1, "unexpected returned real priority level");
-  }
-
-  /* [3.4.3] Raising thread priority above the boosted level.*/
-  test_set_step(3);
-  {
-    p1 = chThdSetPriority(prio + 3);
-    test_assert(p1 == prio + 1, "unexpected returned priority level");
-    test_assert(chThdGetSelfX()->prio == prio + 3, "unexpected priority level");
-    test_assert(chThdGetSelfX()->realprio == prio + 3, "unexpected real priority level");
-  }
-
-  /* [3.4.4] Restoring original conditions.*/
-  test_set_step(4);
-  {
-    chSysLock();
-    chThdGetSelfX()->prio = prio;
-    chThdGetSelfX()->realprio = prio;
-    chSysUnlock();
-  }
-}
-
-static const testcase_t rt_test_003_004 = {
-  "Priority change test with Priority Inheritance",
-  NULL,
-  NULL,
-  rt_test_003_004_execute
-};
-#endif /* CH_CFG_USE_MUTEXES */
-
 /****************************************************************************
  * Exported data.
  ****************************************************************************/
@@ -335,17 +160,13 @@ static const testcase_t rt_test_003_004 = {
 const testcase_t * const rt_test_sequence_003_array[] = {
   &rt_test_003_001,
   &rt_test_003_002,
-  &rt_test_003_003,
-#if (CH_CFG_USE_MUTEXES) || defined(__DOXYGEN__)
-  &rt_test_003_004,
-#endif
   NULL
 };
 
 /**
- * @brief   Threads Functionality.
+ * @brief   Time and Intervals Functionality.
  */
 const testsequence_t rt_test_sequence_003 = {
-  "Threads Functionality",
+  "Time and Intervals Functionality",
   rt_test_sequence_003_array
 };

test/rt/source/test/rt_test_sequence_004.c

@@ -21,16 +21,19 @@
  * @file    rt_test_sequence_004.c
  * @brief   Test Sequence 004 code.
  *
- * @page rt_test_sequence_004 [4] Suspend/Resume
+ * @page rt_test_sequence_004 [4] Threads Functionality
  *
  * File: @ref rt_test_sequence_004.c
  *
  * <h2>Description</h2>
  * This sequence tests the ChibiOS/RT functionalities related to
- * threads suspend/resume.
+ * threading.
  *
  * <h2>Test Cases</h2>
  * - @subpage rt_test_004_001
+ * - @subpage rt_test_004_002
+ * - @subpage rt_test_004_003
+ * - @subpage rt_test_004_004
  * .
  */
 
@@ -38,14 +41,8 @@
  * Shared code.
  ****************************************************************************/
 
-static thread_reference_t tr1;
+static THD_FUNCTION(thread, p) {
 
-static THD_FUNCTION(thread1, p) {
-
-  chSysLock();
-  chThdResumeI(&tr1, MSG_OK);
-  chSchRescheduleS();
-  chSysUnlock();
   test_emit_token(*(char *)p);
 }
 
@@ -54,68 +51,294 @@ static THD_FUNCTION(thread1, p) {
  ****************************************************************************/
 
 /**
- * @page rt_test_004_001 [4.1] Suspend and Resume functionality
+ * @page rt_test_004_001 [4.1] Thread Sleep functionality
  *
  * <h2>Description</h2>
- * The functionality of chThdSuspendTimeoutS() and chThdResumeI() is
+ * The functionality of @p chThdSleep() and derivatives is tested.
- * tested.
  *
  * <h2>Test Steps</h2>
- * - [4.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
+ * - [4.1.1] The current system time is read then a sleep is performed
- *   is remotely resumed with message @p MSG_OK. On return the message
+ *   for 100 system ticks and on exit the system time is verified
- *   and the state of the reference are tested.
+ *   again.
- * - [4.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
+ * - [4.1.2] The current system time is read then a sleep is performed
- *   is not resumed so a timeout must occur. On return the message and
+ *   for 100000 microseconds and on exit the system time is verified
- *   the state of the reference are tested.
+ *   again.
+ * - [4.1.3] The current system time is read then a sleep is performed
+ *   for 100 milliseconds and on exit the system time is verified
+ *   again.
+ * - [4.1.4] The current system time is read then a sleep is performed
+ *   for 1 second and on exit the system time is verified again.
+ * - [4.1.5] Function chThdSleepUntil() is tested with a timeline of
+ *   "now" + 100 ticks.
  * .
  */
 
-static void rt_test_004_001_setup(void) {
-  tr1 = NULL;
-}
-
 static void rt_test_004_001_execute(void) {
   systime_t time;
-  msg_t msg;
 
-  /* [4.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
+  /* [4.1.1] The current system time is read then a sleep is performed
-     is remotely resumed with message @p MSG_OK. On return the message
+     for 100 system ticks and on exit the system time is verified
-     and the state of the reference are tested.*/
+     again.*/
   test_set_step(1);
   {
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-1, thread1, "A");
+    time = chVTGetSystemTimeX();
-    chSysLock();
+    chThdSleep(100);
-    msg = chThdSuspendTimeoutS(&tr1, TIME_INFINITE);
+    test_assert_time_window(chTimeAddX(time, 100),
-    chSysUnlock();
+                            chTimeAddX(time, 100 + CH_CFG_ST_TIMEDELTA + 1),
-    test_assert(NULL == tr1, "not NULL");
+                            "out of time window");
-    test_assert(MSG_OK == msg,"wrong returned message");
-    test_wait_threads();
   }
+  test_end_step(1);
 
-  /* [4.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
+  /* [4.1.2] The current system time is read then a sleep is performed
-     is not resumed so a timeout must occur. On return the message and
+     for 100000 microseconds and on exit the system time is verified
-     the state of the reference are tested.*/
+     again.*/
   test_set_step(2);
   {
-    chSysLock();
     time = chVTGetSystemTimeX();
-    msg = chThdSuspendTimeoutS(&tr1, TIME_MS2I(1000));
+    chThdSleepMicroseconds(100000);
-    chSysUnlock();
+    test_assert_time_window(chTimeAddX(time, TIME_US2I(100000)),
-    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
+                            chTimeAddX(time, TIME_US2I(100000) + CH_CFG_ST_TIMEDELTA + 1),
-                            chTimeAddX(time, TIME_MS2I(1000) + CH_CFG_ST_TIMEDELTA + 1),
                             "out of time window");
-    test_assert(NULL == tr1, "not NULL");
-    test_assert(MSG_TIMEOUT == msg, "wrong returned message");
   }
+  test_end_step(2);
+
+  /* [4.1.3] The current system time is read then a sleep is performed
+     for 100 milliseconds and on exit the system time is verified
+     again.*/
+  test_set_step(3);
+  {
+    time = chVTGetSystemTimeX();
+    chThdSleepMilliseconds(100);
+    test_assert_time_window(chTimeAddX(time, TIME_MS2I(100)),
+                            chTimeAddX(time, TIME_MS2I(100) + CH_CFG_ST_TIMEDELTA + 1),
+                            "out of time window");
+  }
+  test_end_step(3);
+
+  /* [4.1.4] The current system time is read then a sleep is performed
+     for 1 second and on exit the system time is verified again.*/
+  test_set_step(4);
+  {
+    time = chVTGetSystemTimeX();
+    chThdSleepSeconds(1);
+    test_assert_time_window(chTimeAddX(time, TIME_S2I(1)),
+                            chTimeAddX(time, TIME_S2I(1) + CH_CFG_ST_TIMEDELTA + 1),
+                            "out of time window");
+  }
+  test_end_step(4);
+
+  /* [4.1.5] Function chThdSleepUntil() is tested with a timeline of
+     "now" + 100 ticks.*/
+  test_set_step(5);
+  {
+    time = chVTGetSystemTimeX();
+    chThdSleepUntil(chTimeAddX(time, 100));
+    test_assert_time_window(chTimeAddX(time, 100),
+                            chTimeAddX(time, 100 + CH_CFG_ST_TIMEDELTA + 1),
+                            "out of time window");
+  }
+  test_end_step(5);
 }
 
 static const testcase_t rt_test_004_001 = {
-  "Suspend and Resume functionality",
+  "Thread Sleep functionality",
-  rt_test_004_001_setup,
+  NULL,
   NULL,
   rt_test_004_001_execute
 };
 
+/**
+ * @page rt_test_004_002 [4.2] Ready List functionality, threads priority order
+ *
+ * <h2>Description</h2>
+ * Five threads, are enqueued in the ready list and atomically
+ * executed. The test expects the threads to perform their operations
+ * in correct priority order regardless of the initial order.
+ *
+ * <h2>Test Steps</h2>
+ * - [4.2.1] Creating 5 threads with increasing priority, execution
+ *   sequence is tested.
+ * - [4.2.2] Creating 5 threads with decreasing priority, execution
+ *   sequence is tested.
+ * - [4.2.3] Creating 5 threads with pseudo-random priority, execution
+ *   sequence is tested.
+ * .
+ */
+
+static void rt_test_004_002_execute(void) {
+
+  /* [4.2.1] Creating 5 threads with increasing priority, execution
+     sequence is tested.*/
+  test_set_step(1);
+  {
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
+    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
+    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
+    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
+    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
+    test_wait_threads();
+    test_assert_sequence("ABCDE", "invalid sequence");
+  }
+  test_end_step(1);
+
+  /* [4.2.2] Creating 5 threads with decreasing priority, execution
+     sequence is tested.*/
+  test_set_step(2);
+  {
+    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
+    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
+    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
+    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
+    test_wait_threads();
+    test_assert_sequence("ABCDE", "invalid sequence");
+  }
+  test_end_step(2);
+
+  /* [4.2.3] Creating 5 threads with pseudo-random priority, execution
+     sequence is tested.*/
+  test_set_step(3);
+  {
+    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread, "D");
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread, "E");
+    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread, "A");
+    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread, "B");
+    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread, "C");
+    test_wait_threads();
+    test_assert_sequence("ABCDE", "invalid sequence");
+  }
+  test_end_step(3);
+}
+
+static const testcase_t rt_test_004_002 = {
+  "Ready List functionality, threads priority order",
+  NULL,
+  NULL,
+  rt_test_004_002_execute
+};
+
+/**
+ * @page rt_test_004_003 [4.3] Priority change test
+ *
+ * <h2>Description</h2>
+ * A series of priority changes are performed on the current thread in
+ * order to verify that the priority change happens as expected.
+ *
+ * <h2>Test Steps</h2>
+ * - [4.3.1] Thread priority is increased by one then a check is
+ *   performed.
+ * - [4.3.2] Thread priority is returned to the previous value then a
+ *   check is performed.
+ * .
+ */
+
+static void rt_test_004_003_execute(void) {
+  tprio_t prio, p1;
+
+  /* [4.3.1] Thread priority is increased by one then a check is
+     performed.*/
+  test_set_step(1);
+  {
+    prio = chThdGetPriorityX();
+    p1 = chThdSetPriority(prio + 1);
+    test_assert(p1 == prio, "unexpected returned priority level");
+    test_assert(chThdGetPriorityX() == prio + 1, "unexpected priority level");
+  }
+  test_end_step(1);
+
+  /* [4.3.2] Thread priority is returned to the previous value then a
+     check is performed.*/
+  test_set_step(2);
+  {
+    p1 = chThdSetPriority(p1);
+    test_assert(p1 == prio + 1, "unexpected returned priority level");
+    test_assert(chThdGetPriorityX() == prio, "unexpected priority level");
+  }
+  test_end_step(2);
+}
+
+static const testcase_t rt_test_004_003 = {
+  "Priority change test",
+  NULL,
+  NULL,
+  rt_test_004_003_execute
+};
+
+#if (CH_CFG_USE_MUTEXES) || defined(__DOXYGEN__)
+/**
+ * @page rt_test_004_004 [4.4] Priority change test with Priority Inheritance
+ *
+ * <h2>Description</h2>
+ * A series of priority changes are performed on the current thread in
+ * order to verify that the priority change happens as expected.
+ *
+ * <h2>Conditions</h2>
+ * This test is only executed if the following preprocessor condition
+ * evaluates to true:
+ * - CH_CFG_USE_MUTEXES
+ * .
+ *
+ * <h2>Test Steps</h2>
+ * - [4.4.1] Simulating a priority boost situation (prio > realprio).
+ * - [4.4.2] Raising thread priority above original priority but below
+ *   the boosted level.
+ * - [4.4.3] Raising thread priority above the boosted level.
+ * - [4.4.4] Restoring original conditions.
+ * .
+ */
+
+static void rt_test_004_004_execute(void) {
+  tprio_t prio, p1;
+
+  /* [4.4.1] Simulating a priority boost situation (prio > realprio).*/
+  test_set_step(1);
+  {
+    prio = chThdGetPriorityX();
+    chThdGetSelfX()->prio += 2;
+    test_assert(chThdGetPriorityX() == prio + 2, "unexpected priority level");
+  }
+  test_end_step(1);
+
+  /* [4.4.2] Raising thread priority above original priority but below
+     the boosted level.*/
+  test_set_step(2);
+  {
+    p1 = chThdSetPriority(prio + 1);
+    test_assert(p1 == prio, "unexpected returned priority level");
+    test_assert(chThdGetSelfX()->prio == prio + 2, "unexpected priority level");
+    test_assert(chThdGetSelfX()->realprio == prio + 1, "unexpected returned real priority level");
+  }
+  test_end_step(2);
+
+  /* [4.4.3] Raising thread priority above the boosted level.*/
+  test_set_step(3);
+  {
+    p1 = chThdSetPriority(prio + 3);
+    test_assert(p1 == prio + 1, "unexpected returned priority level");
+    test_assert(chThdGetSelfX()->prio == prio + 3, "unexpected priority level");
+    test_assert(chThdGetSelfX()->realprio == prio + 3, "unexpected real priority level");
+  }
+  test_end_step(3);
+
+  /* [4.4.4] Restoring original conditions.*/
+  test_set_step(4);
+  {
+    chSysLock();
+    chThdGetSelfX()->prio = prio;
+    chThdGetSelfX()->realprio = prio;
+    chSysUnlock();
+  }
+  test_end_step(4);
+}
+
+static const testcase_t rt_test_004_004 = {
+  "Priority change test with Priority Inheritance",
+  NULL,
+  NULL,
+  rt_test_004_004_execute
+};
+#endif /* CH_CFG_USE_MUTEXES */
+
 /****************************************************************************
  * Exported data.
  ****************************************************************************/
@@ -125,13 +348,18 @@ static const testcase_t rt_test_004_001 = {
  */
 const testcase_t * const rt_test_sequence_004_array[] = {
   &rt_test_004_001,
+  &rt_test_004_002,
+  &rt_test_004_003,
+#if (CH_CFG_USE_MUTEXES) || defined(__DOXYGEN__)
+  &rt_test_004_004,
+#endif
   NULL
 };
 
 /**
- * @brief   Suspend/Resume.
+ * @brief   Threads Functionality.
  */
 const testsequence_t rt_test_sequence_004 = {
-  "Suspend/Resume",
+  "Threads Functionality",
   rt_test_sequence_004_array
 };

test/rt/source/test/rt_test_sequence_005.c

@@ -21,66 +21,32 @@
  * @file    rt_test_sequence_005.c
  * @brief   Test Sequence 005 code.
  *
- * @page rt_test_sequence_005 [5] Counter Semaphores
+ * @page rt_test_sequence_005 [5] Suspend/Resume
  *
  * File: @ref rt_test_sequence_005.c
  *
  * <h2>Description</h2>
  * This sequence tests the ChibiOS/RT functionalities related to
- * counter semaphores.
+ * threads suspend/resume.
- *
- * <h2>Conditions</h2>
- * This sequence is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_SEMAPHORES
- * .
  *
  * <h2>Test Cases</h2>
  * - @subpage rt_test_005_001
- * - @subpage rt_test_005_002
- * - @subpage rt_test_005_003
- * - @subpage rt_test_005_004
- * - @subpage rt_test_005_005
- * - @subpage rt_test_005_006
  * .
  */
 
-#if (CH_CFG_USE_SEMAPHORES) || defined(__DOXYGEN__)
-
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
-#include "ch.h"
+static thread_reference_t tr1;
-
-static semaphore_t sem1;
 
 static THD_FUNCTION(thread1, p) {
 
-  chSemWait(&sem1);
-  test_emit_token(*(char *)p);
-}
-
-static THD_FUNCTION(thread2, p) {
-
-  (void)p;
-  chThdSleepMilliseconds(50);
   chSysLock();
-  chSemSignalI(&sem1); /* For coverage reasons */
+  chThdResumeI(&tr1, MSG_OK);
   chSchRescheduleS();
   chSysUnlock();
-}
+  test_emit_token(*(char *)p);
-
-static THD_FUNCTION(thread3, p) {
-
-  (void)p;
-  chSemWait(&sem1);
-  chSemSignal(&sem1);
-}
-
-static THD_FUNCTION(thread4, p) {
-
-  chBSemSignal((binary_semaphore_t *)p);
 }
 
 /****************************************************************************
@@ -88,404 +54,68 @@ static THD_FUNCTION(thread4, p) {
  ****************************************************************************/
 
 /**
- * @page rt_test_005_001 [5.1] Semaphore primitives, no state change
+ * @page rt_test_005_001 [5.1] Suspend and Resume functionality
  *
  * <h2>Description</h2>
- * Wait, Signal and Reset primitives are tested. The testing thread
+ * The functionality of chThdSuspendTimeoutS() and chThdResumeI() is
- * does not trigger a state change.
+ * tested.
  *
  * <h2>Test Steps</h2>
- * - [5.1.1] The function chSemWait() is invoked, after return the
+ * - [5.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
- *   counter and the returned message are tested.
+ *   is remotely resumed with message @p MSG_OK. On return the message
- * - [5.1.2] The function chSemSignal() is invoked, after return the
+ *   and the state of the reference are tested.
- *   counter is tested.
+ * - [5.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
- * - [5.1.3] The function chSemReset() is invoked, after return the
+ *   is not resumed so a timeout must occur. On return the message and
- *   counter is tested.
+ *   the state of the reference are tested.
  * .
  */
 
 static void rt_test_005_001_setup(void) {
-  chSemObjectInit(&sem1, 1);
+  tr1 = NULL;
-}
-
-static void rt_test_005_001_teardown(void) {
-  chSemReset(&sem1, 0);
 }
 
 static void rt_test_005_001_execute(void) {
-
+  systime_t time;
-  /* [5.1.1] The function chSemWait() is invoked, after return the
-     counter and the returned message are tested.*/
-  test_set_step(1);
-  {
-    msg_t msg;
-
-    msg = chSemWait(&sem1);
-    test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
-    test_assert(MSG_OK == msg, "wrong returned message");
-  }
-
-  /* [5.1.2] The function chSemSignal() is invoked, after return the
-     counter is tested.*/
-  test_set_step(2);
-  {
-    chSemSignal(&sem1);
-    test_assert_lock(chSemGetCounterI(&sem1) == 1, "wrong counter value");
-  }
-
-  /* [5.1.3] The function chSemReset() is invoked, after return the
-     counter is tested.*/
-  test_set_step(3);
-  {
-    chSemReset(&sem1, 2);
-    test_assert_lock(chSemGetCounterI(&sem1) == 2, "wrong counter value");
-  }
-}
-
-static const testcase_t rt_test_005_001 = {
-  "Semaphore primitives, no state change",
-  rt_test_005_001_setup,
-  rt_test_005_001_teardown,
-  rt_test_005_001_execute
-};
-
-/**
- * @page rt_test_005_002 [5.2] Semaphore enqueuing test
- *
- * <h2>Description</h2>
- * Five threads with randomized priorities are enqueued to a semaphore
- * then awakened one at time. The test expects that the threads reach
- * their goal in FIFO order or priority order depending on the @p
- * CH_CFG_USE_SEMAPHORES_PRIORITY configuration setting.
- *
- * <h2>Test Steps</h2>
- * - [5.2.1] Five threads are created with mixed priority levels (not
- *   increasing nor decreasing). Threads enqueue on a semaphore
- *   initialized to zero.
- * - [5.2.2] The semaphore is signaled 5 times. The thread activation
- *   sequence is tested.
- * .
- */
-
-static void rt_test_005_002_setup(void) {
-  chSemObjectInit(&sem1, 0);
-}
-
-static void rt_test_005_002_execute(void) {
-
-  /* [5.2.1] Five threads are created with mixed priority levels (not
-     increasing nor decreasing). Threads enqueue on a semaphore
-     initialized to zero.*/
-  test_set_step(1);
-  {
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+5, thread1, "A");
-    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()+1, thread1, "B");
-    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()+3, thread1, "C");
-    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()+4, thread1, "D");
-    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()+2, thread1, "E");
-  }
-
-  /* [5.2.2] The semaphore is signaled 5 times. The thread activation
-     sequence is tested.*/
-  test_set_step(2);
-  {
-    chSemSignal(&sem1);
-    chSemSignal(&sem1);
-    chSemSignal(&sem1);
-    chSemSignal(&sem1);
-    chSemSignal(&sem1);
-    test_wait_threads();
-#if CH_CFG_USE_SEMAPHORES_PRIORITY
-    test_assert_sequence("ADCEB", "invalid sequence");
-#else
-    test_assert_sequence("ABCDE", "invalid sequence");
-#endif
-  }
-}
-
-static const testcase_t rt_test_005_002 = {
-  "Semaphore enqueuing test",
-  rt_test_005_002_setup,
-  NULL,
-  rt_test_005_002_execute
-};
-
-/**
- * @page rt_test_005_003 [5.3] Semaphore timeout test
- *
- * <h2>Description</h2>
- * The three possible semaphore waiting modes (do not wait, wait with
- * timeout, wait without timeout) are explored. The test expects that
- * the semaphore wait function returns the correct value in each of the
- * above scenario and that the semaphore structure status is correct
- * after each operation.
- *
- * <h2>Test Steps</h2>
- * - [5.3.1] Testing special case TIME_IMMEDIATE.
- * - [5.3.2] Testing non-timeout condition.
- * - [5.3.3] Testing timeout condition.
- * .
- */
-
-static void rt_test_005_003_setup(void) {
-  chSemObjectInit(&sem1, 0);
-}
-
-static void rt_test_005_003_execute(void) {
-  unsigned i;
-  systime_t target_time;
   msg_t msg;
 
-  /* [5.3.1] Testing special case TIME_IMMEDIATE.*/
+  /* [5.1.1] The function chThdSuspendTimeoutS() is invoked, the thread
+     is remotely resumed with message @p MSG_OK. On return the message
+     and the state of the reference are tested.*/
   test_set_step(1);
   {
-    msg = chSemWaitTimeout(&sem1, TIME_IMMEDIATE);
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-1, thread1, "A");
-    test_assert(msg == MSG_TIMEOUT, "wrong wake-up message");
+    chSysLock();
-    test_assert(queue_isempty(&sem1.queue), "queue not empty");
+    msg = chThdSuspendTimeoutS(&tr1, TIME_INFINITE);
-    test_assert(sem1.cnt == 0, "counter not zero");
+    chSysUnlock();
-  }
+    test_assert(NULL == tr1, "not NULL");
-
+    test_assert(MSG_OK == msg,"wrong returned message");
-  /* [5.3.2] Testing non-timeout condition.*/
-  test_set_step(2);
-  {
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
-                                   thread2, 0);
-    msg = chSemWaitTimeout(&sem1, TIME_MS2I(500));
     test_wait_threads();
-    test_assert(msg == MSG_OK, "wrong wake-up message");
-    test_assert(queue_isempty(&sem1.queue), "queue not empty");
-    test_assert(sem1.cnt == 0, "counter not zero");
   }
+  test_end_step(1);
 
-  /* [5.3.3] Testing timeout condition.*/
+  /* [5.1.2] The function chThdSuspendTimeoutS() is invoked, the thread
-  test_set_step(3);
+     is not resumed so a timeout must occur. On return the message and
-  {
+     the state of the reference are tested.*/
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(5 * 50));
-    for (i = 0; i < 5; i++) {
-      test_emit_token('A' + i);
-      msg = chSemWaitTimeout(&sem1, TIME_MS2I(50));
-      test_assert(msg == MSG_TIMEOUT, "wrong wake-up message");
-      test_assert(queue_isempty(&sem1.queue), "queue not empty");
-      test_assert(sem1.cnt == 0, "counter not zero");
-    }
-    test_assert_sequence("ABCDE", "invalid sequence");
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-  }
-}
-
-static const testcase_t rt_test_005_003 = {
-  "Semaphore timeout test",
-  rt_test_005_003_setup,
-  NULL,
-  rt_test_005_003_execute
-};
-
-/**
- * @page rt_test_005_004 [5.4] Testing chSemAddCounterI() functionality
- *
- * <h2>Description</h2>
- * The functon is tested by waking up a thread then the semaphore
- * counter value is tested.
- *
- * <h2>Test Steps</h2>
- * - [5.4.1] A thread is created, it goes to wait on the semaphore.
- * - [5.4.2] The semaphore counter is increased by two, it is then
- *   tested to be one, the thread must have completed.
- * .
- */
-
-static void rt_test_005_004_setup(void) {
-  chSemObjectInit(&sem1, 0);
-}
-
-static void rt_test_005_004_execute(void) {
-
-  /* [5.4.1] A thread is created, it goes to wait on the semaphore.*/
-  test_set_step(1);
-  {
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+1, thread1, "A");
-  }
-
-  /* [5.4.2] The semaphore counter is increased by two, it is then
-     tested to be one, the thread must have completed.*/
   test_set_step(2);
   {
     chSysLock();
-    chSemAddCounterI(&sem1, 2);
+    time = chVTGetSystemTimeX();
-    chSchRescheduleS();
+    msg = chThdSuspendTimeoutS(&tr1, TIME_MS2I(1000));
     chSysUnlock();
-    test_wait_threads();
+    test_assert_time_window(chTimeAddX(time, TIME_MS2I(1000)),
-    test_assert_lock(chSemGetCounterI(&sem1) == 1, "invalid counter");
+                            chTimeAddX(time, TIME_MS2I(1000) + CH_CFG_ST_TIMEDELTA + 1),
-    test_assert_sequence("A", "invalid sequence");
+                            "out of time window");
+    test_assert(NULL == tr1, "not NULL");
+    test_assert(MSG_TIMEOUT == msg, "wrong returned message");
   }
+  test_end_step(2);
 }
 
-static const testcase_t rt_test_005_004 = {
+static const testcase_t rt_test_005_001 = {
-  "Testing chSemAddCounterI() functionality",
+  "Suspend and Resume functionality",
-  rt_test_005_004_setup,
+  rt_test_005_001_setup,
   NULL,
-  rt_test_005_004_execute
+  rt_test_005_001_execute
-};
-
-/**
- * @page rt_test_005_005 [5.5] Testing chSemWaitSignal() functionality
- *
- * <h2>Description</h2>
- * This test case explicitly addresses the @p chSemWaitSignal()
- * function. A thread is created that performs a wait and a signal
- * operations. The tester thread is awakened from an atomic wait/signal
- * operation. The test expects that the semaphore wait function returns
- * the correct value in each of the above scenario and that the
- * semaphore structure status is correct after each operation.
- *
- * <h2>Test Steps</h2>
- * - [5.5.1] An higher priority thread is created that performs
- *   non-atomical wait and signal operations on a semaphore.
- * - [5.5.2] The function chSemSignalWait() is invoked by specifying
- *   the same semaphore for the wait and signal phases. The counter
- *   value must be one on exit.
- * - [5.5.3] The function chSemSignalWait() is invoked again by
- *   specifying the same semaphore for the wait and signal phases. The
- *   counter value must be one on exit.
- * .
- */
-
-static void rt_test_005_005_setup(void) {
-  chSemObjectInit(&sem1, 0);
-}
-
-static void rt_test_005_005_teardown(void) {
-  test_wait_threads();
-}
-
-static void rt_test_005_005_execute(void) {
-
-  /* [5.5.1] An higher priority thread is created that performs
-     non-atomical wait and signal operations on a semaphore.*/
-  test_set_step(1);
-  {
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+1, thread3, 0);
-  }
-
-  /* [5.5.2] The function chSemSignalWait() is invoked by specifying
-     the same semaphore for the wait and signal phases. The counter
-     value must be one on exit.*/
-  test_set_step(2);
-  {
-    chSemSignalWait(&sem1, &sem1);
-    test_assert(queue_isempty(&sem1.queue), "queue not empty");
-    test_assert(sem1.cnt == 0, "counter not zero");
-  }
-
-  /* [5.5.3] The function chSemSignalWait() is invoked again by
-     specifying the same semaphore for the wait and signal phases. The
-     counter value must be one on exit.*/
-  test_set_step(3);
-  {
-    chSemSignalWait(&sem1, &sem1);
-    test_assert(queue_isempty(&sem1.queue), "queue not empty");
-    test_assert(sem1.cnt == 0, "counter not zero");
-  }
-}
-
-static const testcase_t rt_test_005_005 = {
-  "Testing chSemWaitSignal() functionality",
-  rt_test_005_005_setup,
-  rt_test_005_005_teardown,
-  rt_test_005_005_execute
-};
-
-/**
- * @page rt_test_005_006 [5.6] Testing Binary Semaphores special case
- *
- * <h2>Description</h2>
- * This test case tests the binary semaphores functionality. The test
- * both checks the binary semaphore status and the expected status of
- * the underlying counting semaphore.
- *
- * <h2>Test Steps</h2>
- * - [5.6.1] Creating a binary semaphore in "taken" state, the state is
- *   checked.
- * - [5.6.2] Resetting the binary semaphore in "taken" state, the state
- *   must not change.
- * - [5.6.3] Starting a signaler thread at a lower priority.
- * - [5.6.4] Waiting for the binary semaphore to be signaled, the
- *   semaphore is expected to be taken.
- * - [5.6.5] Signaling the binary semaphore, checking the binary
- *   semaphore state to be "not taken" and the underlying counter
- *   semaphore counter to be one.
- * - [5.6.6] Signaling the binary semaphore again, the internal state
- *   must not change from "not taken".
- * .
- */
-
-static void rt_test_005_006_teardown(void) {
-  test_wait_threads();
-}
-
-static void rt_test_005_006_execute(void) {
-  binary_semaphore_t bsem;
-  msg_t msg;
-
-  /* [5.6.1] Creating a binary semaphore in "taken" state, the state is
-     checked.*/
-  test_set_step(1);
-  {
-    chBSemObjectInit(&bsem, true);
-    test_assert_lock(chBSemGetStateI(&bsem) == true, "not taken");
-  }
-
-  /* [5.6.2] Resetting the binary semaphore in "taken" state, the state
-     must not change.*/
-  test_set_step(2);
-  {
-    chBSemReset(&bsem, true);
-    test_assert_lock(chBSemGetStateI(&bsem) == true, "not taken");
-  }
-
-  /* [5.6.3] Starting a signaler thread at a lower priority.*/
-  test_set_step(3);
-  {
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE,
-                                   chThdGetPriorityX()-1, thread4, &bsem);
-  }
-
-  /* [5.6.4] Waiting for the binary semaphore to be signaled, the
-     semaphore is expected to be taken.*/
-  test_set_step(4);
-  {
-    msg = chBSemWait(&bsem);
-    test_assert_lock(chBSemGetStateI(&bsem) == true, "not taken");
-    test_assert(msg == MSG_OK, "unexpected message");
-  }
-
-  /* [5.6.5] Signaling the binary semaphore, checking the binary
-     semaphore state to be "not taken" and the underlying counter
-     semaphore counter to be one.*/
-  test_set_step(5);
-  {
-    chBSemSignal(&bsem);
-    test_assert_lock(chBSemGetStateI(&bsem) ==false, "still taken");
-    test_assert_lock(chSemGetCounterI(&bsem.sem) == 1, "unexpected counter");
-  }
-
-  /* [5.6.6] Signaling the binary semaphore again, the internal state
-     must not change from "not taken".*/
-  test_set_step(6);
-  {
-    chBSemSignal(&bsem);
-    test_assert_lock(chBSemGetStateI(&bsem) == false, "taken");
-    test_assert_lock(chSemGetCounterI(&bsem.sem) == 1, "unexpected counter");
-  }
-}
-
-static const testcase_t rt_test_005_006 = {
-  "Testing Binary Semaphores special case",
-  NULL,
-  rt_test_005_006_teardown,
-  rt_test_005_006_execute
 };
 
 /****************************************************************************
@@ -497,20 +127,13 @@ static const testcase_t rt_test_005_006 = {
  */
 const testcase_t * const rt_test_sequence_005_array[] = {
   &rt_test_005_001,
-  &rt_test_005_002,
-  &rt_test_005_003,
-  &rt_test_005_004,
-  &rt_test_005_005,
-  &rt_test_005_006,
   NULL
 };
 
 /**
- * @brief   Counter Semaphores.
+ * @brief   Suspend/Resume.
  */
 const testsequence_t rt_test_sequence_005 = {
-  "Counter Semaphores",
+  "Suspend/Resume",
   rt_test_sequence_005_array
 };
-
-#endif /* CH_CFG_USE_SEMAPHORES */

test/rt/source/test/rt_test_sequence_008.c

@@ -21,56 +21,37 @@
  * @file    rt_test_sequence_008.c
  * @brief   Test Sequence 008 code.
  *
- * @page rt_test_sequence_008 [8] Event Sources and Event Flags
+ * @page rt_test_sequence_008 [8] Synchronous Messages
  *
  * File: @ref rt_test_sequence_008.c
  *
  * <h2>Description</h2>
- * This module implements the test sequence for the Events subsystem.
+ * This module implements the test sequence for the Synchronous
+ * Messages subsystem.
  *
  * <h2>Conditions</h2>
  * This sequence is only executed if the following preprocessor condition
  * evaluates to true:
- * - CH_CFG_USE_EVENTS
+ * - CH_CFG_USE_MESSAGES
  * .
  *
  * <h2>Test Cases</h2>
  * - @subpage rt_test_008_001
- * - @subpage rt_test_008_002
- * - @subpage rt_test_008_003
- * - @subpage rt_test_008_004
- * - @subpage rt_test_008_005
- * - @subpage rt_test_008_006
- * - @subpage rt_test_008_007
  * .
  */
 
-#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
+#if (CH_CFG_USE_MESSAGES) || defined(__DOXYGEN__)
 
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
-static EVENTSOURCE_DECL(es1);
+static THD_FUNCTION(msg_thread1, p) {
-static EVENTSOURCE_DECL(es2);
 
-static void h1(eventid_t id) {(void)id;test_emit_token('A');}
+  chMsgSend(p, 'A');
-static void h2(eventid_t id) {(void)id;test_emit_token('B');}
+  chMsgSend(p, 'B');
-static void h3(eventid_t id) {(void)id;test_emit_token('C');}
+  chMsgSend(p, 'C');
-static ROMCONST evhandler_t evhndl[] = {h1, h2, h3};
+  chMsgSend(p, 'D');
-
-static THD_FUNCTION(evt_thread3, p) {
-
-  chThdSleepMilliseconds(50);
-  chEvtSignal((thread_t *)p, 1);
-}
-
-static THD_FUNCTION(evt_thread7, p) {
-
-  (void)p;
-  chEvtBroadcast(&es1);
-  chThdSleepMilliseconds(50);
-  chEvtBroadcast(&es2);
 }
 
 /****************************************************************************
@@ -78,477 +59,56 @@ static THD_FUNCTION(evt_thread7, p) {
  ****************************************************************************/
 
 /**
- * @page rt_test_008_001 [8.1] Events registration
+ * @page rt_test_008_001 [8.1] Messages Server loop
  *
  * <h2>Description</h2>
- * Two event listeners are registered on an event source and then
+ * A messenger thread is spawned that sends four messages back to the
- * unregistered in the same order.<br> The test expects that the even
+ * tester thread.<br> The test expect to receive the messages in the
- * source has listeners after the registrations and after the first
+ * correct sequence and to not find a fifth message waiting.
- * unregistration, then, after the second unegistration, the test
- * expects no more listeners.
  *
  * <h2>Test Steps</h2>
- * - [8.1.1] An Event Source is initialized.
+ * - [8.1.1] Starting the messenger thread.
- * - [8.1.2] Two Event Listeners are registered on the Event Source,
+ * - [8.1.2] Waiting for four messages then testing the receive order.
- *   the Event Source is tested to have listeners.
- * - [8.1.3] An Event Listener is unregistered, the Event Source must
- *   still have listeners.
- * - [8.1.4] An Event Listener is unregistered, the Event Source must
- *   not have listeners.
  * .
  */
 
 static void rt_test_008_001_execute(void) {
-  event_listener_t el1, el2;
+  thread_t *tp;
+  msg_t msg;
 
-  /* [8.1.1] An Event Source is initialized.*/
+  /* [8.1.1] Starting the messenger thread.*/
   test_set_step(1);
   {
-    chEvtObjectInit(&es1);
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() + 1,
+                                   msg_thread1, chThdGetSelfX());
   }
+  test_end_step(1);
 
-  /* [8.1.2] Two Event Listeners are registered on the Event Source,
+  /* [8.1.2] Waiting for four messages then testing the receive
-     the Event Source is tested to have listeners.*/
+     order.*/
   test_set_step(2);
   {
-    chEvtRegisterMask(&es1, &el1, 1);
+    unsigned i;
-    chEvtRegisterMask(&es1, &el2, 2);
-    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
-  }
 
-  /* [8.1.3] An Event Listener is unregistered, the Event Source must
+    for (i = 0; i < 4; i++) {
-     still have listeners.*/
+      tp = chMsgWait();
-  test_set_step(3);
+      msg = chMsgGet(tp);
-  {
+      chMsgRelease(tp, msg);
-    chEvtUnregister(&es1, &el1);
+      test_emit_token(msg);
-    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
+    }
-  }
+    test_wait_threads();
-
+    test_assert_sequence("ABCD", "invalid sequence");
-  /* [8.1.4] An Event Listener is unregistered, the Event Source must
-     not have listeners.*/
-  test_set_step(4);
-  {
-    chEvtUnregister(&es1, &el2);
-    test_assert_lock(!chEvtIsListeningI(&es1), "stuck listener");
   }
+  test_end_step(2);
 }
 
 static const testcase_t rt_test_008_001 = {
-  "Events registration",
+  "Messages Server loop",
   NULL,
   NULL,
   rt_test_008_001_execute
 };
 
-/**
- * @page rt_test_008_002 [8.2] Event Flags dispatching
- *
- * <h2>Description</h2>
- * The test dispatches three event flags and verifies that the
- * associated event handlers are invoked in LSb-first order.
- *
- * <h2>Test Steps</h2>
- * - [8.2.1] Three evenf flag bits are raised then chEvtDispatch() is
- *   invoked, the sequence of handlers calls is tested.
- * .
- */
-
-static void rt_test_008_002_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void rt_test_008_002_execute(void) {
-
-  /* [8.2.1] Three evenf flag bits are raised then chEvtDispatch() is
-     invoked, the sequence of handlers calls is tested.*/
-  test_set_step(1);
-  {
-    chEvtDispatch(evhndl, 7);
-    test_assert_sequence("ABC", "invalid sequence");
-  }
-}
-
-static const testcase_t rt_test_008_002 = {
-  "Event Flags dispatching",
-  rt_test_008_002_setup,
-  NULL,
-  rt_test_008_002_execute
-};
-
-/**
- * @page rt_test_008_003 [8.3] Events Flags wait using chEvtWaitOne()
- *
- * <h2>Description</h2>
- * Functionality of chEvtWaitOne() is tested under various scenarios.
- *
- * <h2>Test Steps</h2>
- * - [8.3.1] Setting three event flags.
- * - [8.3.2] Calling chEvtWaitOne() three times, each time a single
- *   flag must be returned in order of priority.
- * - [8.3.3] Getting current time and starting a signaler thread, the
- *   thread will set an event flag after 50mS.
- * - [8.3.4] Calling chEvtWaitOne() then verifying that the event has
- *   been received after 50mS and that the event flags mask has been
- *   emptied.
- * .
- */
-
-static void rt_test_008_003_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void rt_test_008_003_execute(void) {
-  eventmask_t m;
-  systime_t target_time;
-
-  /* [8.3.1] Setting three event flags.*/
-  test_set_step(1);
-  {
-    chEvtAddEvents(7);
-  }
-
-  /* [8.3.2] Calling chEvtWaitOne() three times, each time a single
-     flag must be returned in order of priority.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert(m == 1, "single event error");
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert(m == 2, "single event error");
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert(m == 4, "single event error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-  }
-
-  /* [8.3.3] Getting current time and starting a signaler thread, the
-     thread will set an event flag after 50mS.*/
-  test_set_step(3);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
-                                   evt_thread3, chThdGetSelfX());
-  }
-
-  /* [8.3.4] Calling chEvtWaitOne() then verifying that the event has
-     been received after 50mS and that the event flags mask has been
-     emptied.*/
-  test_set_step(4);
-  {
-    m = chEvtWaitOne(ALL_EVENTS);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    test_assert(m == 1, "event flag error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    test_wait_threads();
-  }
-}
-
-static const testcase_t rt_test_008_003 = {
-  "Events Flags wait using chEvtWaitOne()",
-  rt_test_008_003_setup,
-  NULL,
-  rt_test_008_003_execute
-};
-
-/**
- * @page rt_test_008_004 [8.4] Events Flags wait using chEvtWaitAny()
- *
- * <h2>Description</h2>
- * Functionality of chEvtWaitAny() is tested under various scenarios.
- *
- * <h2>Test Steps</h2>
- * - [8.4.1] Setting two, non contiguous, event flags.
- * - [8.4.2] Calling chEvtWaitAny() one time, the two flags must be
- *   returned.
- * - [8.4.3] Getting current time and starting a signaler thread, the
- *   thread will set an event flag after 50mS.
- * - [8.4.4] Calling chEvtWaitAny() then verifying that the event has
- *   been received after 50mS and that the event flags mask has been
- *   emptied.
- * .
- */
-
-static void rt_test_008_004_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void rt_test_008_004_execute(void) {
-  eventmask_t m;
-  systime_t target_time;
-
-  /* [8.4.1] Setting two, non contiguous, event flags.*/
-  test_set_step(1);
-  {
-    chEvtAddEvents(5);
-  }
-
-  /* [8.4.2] Calling chEvtWaitAny() one time, the two flags must be
-     returned.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitAny(ALL_EVENTS);
-    test_assert(m == 5, "unexpected pending bit");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-  }
-
-  /* [8.4.3] Getting current time and starting a signaler thread, the
-     thread will set an event flag after 50mS.*/
-  test_set_step(3);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
-                                   evt_thread3, chThdGetSelfX());
-  }
-
-  /* [8.4.4] Calling chEvtWaitAny() then verifying that the event has
-     been received after 50mS and that the event flags mask has been
-     emptied.*/
-  test_set_step(4);
-  {
-    m = chEvtWaitAny(ALL_EVENTS);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    test_assert(m == 1, "event flag error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    test_wait_threads();
-  }
-}
-
-static const testcase_t rt_test_008_004 = {
-  "Events Flags wait using chEvtWaitAny()",
-  rt_test_008_004_setup,
-  NULL,
-  rt_test_008_004_execute
-};
-
-/**
- * @page rt_test_008_005 [8.5] Events Flags wait using chEvtWaitAll()
- *
- * <h2>Description</h2>
- * Functionality of chEvtWaitAll() is tested under various scenarios.
- *
- * <h2>Test Steps</h2>
- * - [8.5.1] Setting two, non contiguous, event flags.
- * - [8.5.2] Calling chEvtWaitAll() one time, the two flags must be
- *   returned.
- * - [8.5.3] Setting one event flag.
- * - [8.5.4] Getting current time and starting a signaler thread, the
- *   thread will set another event flag after 50mS.
- * - [8.5.5] Calling chEvtWaitAll() then verifying that both event
- *   flags have been received after 50mS and that the event flags mask
- *   has been emptied.
- * .
- */
-
-static void rt_test_008_005_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void rt_test_008_005_execute(void) {
-  eventmask_t m;
-  systime_t target_time;
-
-  /* [8.5.1] Setting two, non contiguous, event flags.*/
-  test_set_step(1);
-  {
-    chEvtAddEvents(5);
-  }
-
-  /* [8.5.2] Calling chEvtWaitAll() one time, the two flags must be
-     returned.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitAll(5);
-    test_assert(m == 5, "unexpected pending bit");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-  }
-
-  /* [8.5.3] Setting one event flag.*/
-  test_set_step(3);
-  {
-    chEvtAddEvents(4);
-  }
-
-  /* [8.5.4] Getting current time and starting a signaler thread, the
-     thread will set another event flag after 50mS.*/
-  test_set_step(4);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
-                                   evt_thread3, chThdGetSelfX());
-  }
-
-  /* [8.5.5] Calling chEvtWaitAll() then verifying that both event
-     flags have been received after 50mS and that the event flags mask
-     has been emptied.*/
-  test_set_step(5);
-  {
-    m = chEvtWaitAll(5);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    test_assert(m == 5, "event flags error");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    test_wait_threads();
-  }
-}
-
-static const testcase_t rt_test_008_005 = {
-  "Events Flags wait using chEvtWaitAll()",
-  rt_test_008_005_setup,
-  NULL,
-  rt_test_008_005_execute
-};
-
-#if (CH_CFG_USE_EVENTS_TIMEOUT) || defined(__DOXYGEN__)
-/**
- * @page rt_test_008_006 [8.6] Events Flags wait timeouts
- *
- * <h2>Description</h2>
- * Timeout functionality is tested for chEvtWaitOneTimeout(),
- * chEvtWaitAnyTimeout() and chEvtWaitAllTimeout().
- *
- * <h2>Conditions</h2>
- * This test is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_EVENTS_TIMEOUT
- * .
- *
- * <h2>Test Steps</h2>
- * - [8.6.1] The functions are invoked first with TIME_IMMEDIATE
- *   timeout, the timeout condition is tested.
- * - [8.6.2] The functions are invoked first with a 50mS timeout, the
- *   timeout condition is tested.
- * .
- */
-
-static void rt_test_008_006_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-}
-
-static void rt_test_008_006_execute(void) {
-  eventmask_t m;
-
-  /* [8.6.1] The functions are invoked first with TIME_IMMEDIATE
-     timeout, the timeout condition is tested.*/
-  test_set_step(1);
-  {
-    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_IMMEDIATE);
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_IMMEDIATE);
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_IMMEDIATE);
-    test_assert(m == 0, "spurious event");
-  }
-
-  /* [8.6.2] The functions are invoked first with a 50mS timeout, the
-     timeout condition is tested.*/
-  test_set_step(2);
-  {
-    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_MS2I(50));
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_MS2I(50));
-    test_assert(m == 0, "spurious event");
-    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_MS2I(50));
-    test_assert(m == 0, "spurious event");
-  }
-}
-
-static const testcase_t rt_test_008_006 = {
-  "Events Flags wait timeouts",
-  rt_test_008_006_setup,
-  NULL,
-  rt_test_008_006_execute
-};
-#endif /* CH_CFG_USE_EVENTS_TIMEOUT */
-
-/**
- * @page rt_test_008_007 [8.7] Broadcasting using chEvtBroadcast()
- *
- * <h2>Description</h2>
- * Functionality of chEvtBroadcast() is tested.
- *
- * <h2>Test Steps</h2>
- * - [8.7.1] Registering on two event sources associating them with
- *   flags 1 and 4.
- * - [8.7.2] Getting current time and starting a broadcaster thread,
- *   the thread broadcast the first Event Source immediately and the
- *   other after 50mS.
- * - [8.7.3] Calling chEvtWaitAll() then verifying that both event
- *   flags have been received after 50mS and that the event flags mask
- *   has been emptied.
- * - [8.7.4] Unregistering from the Event Sources.
- * .
- */
-
-static void rt_test_008_007_setup(void) {
-  chEvtGetAndClearEvents(ALL_EVENTS);
-  chEvtObjectInit(&es1);
-  chEvtObjectInit(&es2);
-}
-
-static void rt_test_008_007_execute(void) {
-  eventmask_t m;
-  event_listener_t el1, el2;
-  systime_t target_time;
-
-  /* [8.7.1] Registering on two event sources associating them with
-     flags 1 and 4.*/
-  test_set_step(1);
-  {
-    chEvtRegisterMask(&es1, &el1, 1);
-    chEvtRegisterMask(&es2, &el2, 4);
-  }
-
-  /* [8.7.2] Getting current time and starting a broadcaster thread,
-     the thread broadcast the first Event Source immediately and the
-     other after 50mS.*/
-  test_set_step(2);
-  {
-    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
-    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
-                                   evt_thread7, "A");
-  }
-
-  /* [8.7.3] Calling chEvtWaitAll() then verifying that both event
-     flags have been received after 50mS and that the event flags mask
-     has been emptied.*/
-  test_set_step(3);
-  {
-    m = chEvtWaitAll(5);
-    test_assert_time_window(target_time,
-                            chTimeAddX(target_time, ALLOWED_DELAY),
-                            "out of time window");
-    m = chEvtGetAndClearEvents(ALL_EVENTS);
-    test_assert(m == 0, "stuck event");
-    test_wait_threads();
-  }
-
-  /* [8.7.4] Unregistering from the Event Sources.*/
-  test_set_step(4);
-  {
-    chEvtUnregister(&es1, &el1);
-    chEvtUnregister(&es2, &el2);
-    test_assert(!chEvtIsListeningI(&es1), "stuck listener");
-    test_assert(!chEvtIsListeningI(&es2), "stuck listener");
-  }
-}
-
-static const testcase_t rt_test_008_007 = {
-  "Broadcasting using chEvtBroadcast()",
-  rt_test_008_007_setup,
-  NULL,
-  rt_test_008_007_execute
-};
-
 /****************************************************************************
  * Exported data.
  ****************************************************************************/
@@ -558,23 +118,15 @@ static const testcase_t rt_test_008_007 = {
  */
 const testcase_t * const rt_test_sequence_008_array[] = {
   &rt_test_008_001,
-  &rt_test_008_002,
-  &rt_test_008_003,
-  &rt_test_008_004,
-  &rt_test_008_005,
-#if (CH_CFG_USE_EVENTS_TIMEOUT) || defined(__DOXYGEN__)
-  &rt_test_008_006,
-#endif
-  &rt_test_008_007,
   NULL
 };
 
 /**
- * @brief   Event Sources and Event Flags.
+ * @brief   Synchronous Messages.
  */
 const testsequence_t rt_test_sequence_008 = {
-  "Event Sources and Event Flags",
+  "Synchronous Messages",
   rt_test_sequence_008_array
 };
 
-#endif /* CH_CFG_USE_EVENTS */
+#endif /* CH_CFG_USE_MESSAGES */

test/rt/source/test/rt_test_sequence_009.c

@@ -21,247 +21,557 @@
  * @file    rt_test_sequence_009.c
  * @brief   Test Sequence 009 code.
  *
- * @page rt_test_sequence_009 [9] Dynamic threads
+ * @page rt_test_sequence_009 [9] Event Sources and Event Flags
  *
  * File: @ref rt_test_sequence_009.c
  *
  * <h2>Description</h2>
- * This module implements the test sequence for the dynamic thread
+ * This module implements the test sequence for the Events subsystem.
- * creation APIs.
  *
  * <h2>Conditions</h2>
  * This sequence is only executed if the following preprocessor condition
  * evaluates to true:
- * - CH_CFG_USE_DYNAMIC
+ * - CH_CFG_USE_EVENTS
  * .
  *
  * <h2>Test Cases</h2>
  * - @subpage rt_test_009_001
  * - @subpage rt_test_009_002
+ * - @subpage rt_test_009_003
+ * - @subpage rt_test_009_004
+ * - @subpage rt_test_009_005
+ * - @subpage rt_test_009_006
+ * - @subpage rt_test_009_007
  * .
  */
 
-#if (CH_CFG_USE_DYNAMIC) || defined(__DOXYGEN__)
+#if (CH_CFG_USE_EVENTS) || defined(__DOXYGEN__)
 
 /****************************************************************************
  * Shared code.
  ****************************************************************************/
 
-#if CH_CFG_USE_HEAP
+static EVENTSOURCE_DECL(es1);
-static memory_heap_t heap1;
+static EVENTSOURCE_DECL(es2);
-#endif
-#if CH_CFG_USE_MEMPOOLS
-static memory_pool_t mp1;
-#endif
 
-static THD_FUNCTION(dyn_thread1, p) {
+static void h1(eventid_t id) {(void)id;test_emit_token('A');}
+static void h2(eventid_t id) {(void)id;test_emit_token('B');}
+static void h3(eventid_t id) {(void)id;test_emit_token('C');}
+static ROMCONST evhandler_t evhndl[] = {h1, h2, h3};
 
-  test_emit_token(*(char *)p);
+static THD_FUNCTION(evt_thread3, p) {
+
+  chThdSleepMilliseconds(50);
+  chEvtSignal((thread_t *)p, 1);
+}
+
+static THD_FUNCTION(evt_thread7, p) {
+
+  (void)p;
+  chEvtBroadcast(&es1);
+  chThdSleepMilliseconds(50);
+  chEvtBroadcast(&es2);
 }
 
 /****************************************************************************
  * Test cases.
  ****************************************************************************/
 
-#if (CH_CFG_USE_HEAP) || defined(__DOXYGEN__)
 /**
- * @page rt_test_009_001 [9.1] Threads creation from Memory Heap
+ * @page rt_test_009_001 [9.1] Events registration
  *
  * <h2>Description</h2>
- * Two threads are started by allocating the memory from the Memory
+ * Two event listeners are registered on an event source and then
- * Heap then a third thread is started with a huge stack
+ * unregistered in the same order.<br> The test expects that the even
- * requirement.<br> The test expects the first two threads to
+ * source has listeners after the registrations and after the first
- * successfully start and the third one to fail.
+ * unregistration, then, after the second unegistration, the test
- *
+ * expects no more listeners.
- * <h2>Conditions</h2>
- * This test is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_HEAP
- * .
  *
  * <h2>Test Steps</h2>
- * - [9.1.1] Getting base priority for threads.
+ * - [9.1.1] An Event Source is initialized.
- * - [9.1.2] Getting heap info before the test.
+ * - [9.1.2] Two Event Listeners are registered on the Event Source,
- * - [9.1.3] Creating thread 1, it is expected to succeed.
+ *   the Event Source is tested to have listeners.
- * - [9.1.4] Creating thread 2, it is expected to succeed.
+ * - [9.1.3] An Event Listener is unregistered, the Event Source must
- * - [9.1.5] Creating thread 3, it is expected to fail.
+ *   still have listeners.
- * - [9.1.6] Letting threads execute then checking the start order and
+ * - [9.1.4] An Event Listener is unregistered, the Event Source must
- *   freeing memory.
+ *   not have listeners.
- * - [9.1.7] Getting heap info again for verification.
  * .
  */
 
-static void rt_test_009_001_setup(void) {
-  chHeapObjectInit(&heap1, test_buffer, sizeof test_buffer);
-}
-
 static void rt_test_009_001_execute(void) {
-  size_t n1, total1, largest1;
+  event_listener_t el1, el2;
-  size_t n2, total2, largest2;
-  tprio_t prio;
 
-  /* [9.1.1] Getting base priority for threads.*/
+  /* [9.1.1] An Event Source is initialized.*/
   test_set_step(1);
   {
-    prio = chThdGetPriorityX();
+    chEvtObjectInit(&es1);
   }
+  test_end_step(1);
 
-  /* [9.1.2] Getting heap info before the test.*/
+  /* [9.1.2] Two Event Listeners are registered on the Event Source,
+     the Event Source is tested to have listeners.*/
   test_set_step(2);
   {
-    n1 = chHeapStatus(&heap1, &total1, &largest1);
+    chEvtRegisterMask(&es1, &el1, 1);
-    test_assert(n1 == 1, "heap fragmented");
+    chEvtRegisterMask(&es1, &el2, 2);
+    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
   }
+  test_end_step(2);
 
-  /* [9.1.3] Creating thread 1, it is expected to succeed.*/
+  /* [9.1.3] An Event Listener is unregistered, the Event Source must
+     still have listeners.*/
   test_set_step(3);
   {
-    threads[0] = chThdCreateFromHeap(&heap1,
+    chEvtUnregister(&es1, &el1);
-                                     THD_WORKING_AREA_SIZE(THREADS_STACK_SIZE),
+    test_assert_lock(chEvtIsListeningI(&es1), "no listener");
-                                     "dyn1",
-                                     prio-1, dyn_thread1, "A");
-    test_assert(threads[0] != NULL, "thread creation failed");
   }
+  test_end_step(3);
 
-  /* [9.1.4] Creating thread 2, it is expected to succeed.*/
+  /* [9.1.4] An Event Listener is unregistered, the Event Source must
+     not have listeners.*/
   test_set_step(4);
   {
-    threads[1] = chThdCreateFromHeap(&heap1,
+    chEvtUnregister(&es1, &el2);
-                                     THD_WORKING_AREA_SIZE(THREADS_STACK_SIZE),
+    test_assert_lock(!chEvtIsListeningI(&es1), "stuck listener");
-                                     "dyn2",
-                                     prio-2, dyn_thread1, "B");
-    test_assert(threads[1] != NULL, "thread creation failed");
-  }
-
-  /* [9.1.5] Creating thread 3, it is expected to fail.*/
-  test_set_step(5);
-  {
-    threads[2] = chThdCreateFromHeap(&heap1,
-                                     (((size_t)-1) >> 1U) + 1U,
-                                     "dyn3",
-                                     prio-3, dyn_thread1, "C");
-    test_assert(threads[2] == NULL, "thread creation not failed");
-  }
-
-  /* [9.1.6] Letting threads execute then checking the start order and
-     freeing memory.*/
-  test_set_step(6);
-  {
-    test_wait_threads();
-    test_assert_sequence("AB", "invalid sequence");
-  }
-
-  /* [9.1.7] Getting heap info again for verification.*/
-  test_set_step(7);
-  {
-    n2 = chHeapStatus(&heap1, &total2, &largest2);
-    test_assert(n1 == n2, "fragmentation changed");
-    test_assert(total1 == total2, "total free space changed");
-    test_assert(largest1 == largest2, "largest fragment size changed");
   }
+  test_end_step(4);
 }
 
 static const testcase_t rt_test_009_001 = {
-  "Threads creation from Memory Heap",
+  "Events registration",
-  rt_test_009_001_setup,
+  NULL,
   NULL,
   rt_test_009_001_execute
 };
-#endif /* CH_CFG_USE_HEAP */
 
-#if (CH_CFG_USE_MEMPOOLS) || defined(__DOXYGEN__)
 /**
- * @page rt_test_009_002 [9.2] Threads creation from Memory Pool
+ * @page rt_test_009_002 [9.2] Event Flags dispatching
  *
  * <h2>Description</h2>
- * Five thread creation are attempted from a pool containing only four
+ * The test dispatches three event flags and verifies that the
- * elements.<br> The test expects the first four threads to
+ * associated event handlers are invoked in LSb-first order.
- * successfully start and the last one to fail.
- *
- * <h2>Conditions</h2>
- * This test is only executed if the following preprocessor condition
- * evaluates to true:
- * - CH_CFG_USE_MEMPOOLS
- * .
  *
  * <h2>Test Steps</h2>
- * - [9.2.1] Adding four working areas to the pool.
+ * - [9.2.1] Three evenf flag bits are raised then chEvtDispatch() is
- * - [9.2.2] Getting base priority for threads.
+ *   invoked, the sequence of handlers calls is tested.
- * - [9.2.3] Creating the five threads.
- * - [9.2.4] Testing that only the fifth thread creation failed.
- * - [9.2.5] Letting them run, free the memory then checking the
- *   execution sequence.
- * - [9.2.6] Testing that the pool contains four elements again.
  * .
  */
 
 static void rt_test_009_002_setup(void) {
-  chPoolObjectInit(&mp1, THD_WORKING_AREA_SIZE(THREADS_STACK_SIZE), NULL);
+  chEvtGetAndClearEvents(ALL_EVENTS);
 }
 
 static void rt_test_009_002_execute(void) {
-  unsigned i;
-  tprio_t prio;
 
-  /* [9.2.1] Adding four working areas to the pool.*/
+  /* [9.2.1] Three evenf flag bits are raised then chEvtDispatch() is
+     invoked, the sequence of handlers calls is tested.*/
   test_set_step(1);
   {
-    for (i = 0; i < 4; i++)
+    chEvtDispatch(evhndl, 7);
-      chPoolFree(&mp1, wa[i]);
+    test_assert_sequence("ABC", "invalid sequence");
-  }
-
-  /* [9.2.2] Getting base priority for threads.*/
-  test_set_step(2);
-  {
-    prio = chThdGetPriorityX();
-  }
-
-  /* [9.2.3] Creating the five threads.*/
-  test_set_step(3);
-  {
-    threads[0] = chThdCreateFromMemoryPool(&mp1, "dyn1", prio-1, dyn_thread1, "A");
-    threads[1] = chThdCreateFromMemoryPool(&mp1, "dyn2", prio-2, dyn_thread1, "B");
-    threads[2] = chThdCreateFromMemoryPool(&mp1, "dyn3", prio-3, dyn_thread1, "C");
-    threads[3] = chThdCreateFromMemoryPool(&mp1, "dyn4", prio-4, dyn_thread1, "D");
-    threads[4] = chThdCreateFromMemoryPool(&mp1, "dyn5", prio-5, dyn_thread1, "E");
-  }
-
-  /* [9.2.4] Testing that only the fifth thread creation failed.*/
-  test_set_step(4);
-  {
-    test_assert((threads[0] != NULL) &&
-                (threads[1] != NULL) &&
-                (threads[2] != NULL) &&
-                (threads[3] != NULL),
-                "thread creation failed");
-    test_assert(threads[4] == NULL,
-                "thread creation not failed");
-  }
-
-  /* [9.2.5] Letting them run, free the memory then checking the
-     execution sequence.*/
-  test_set_step(5);
-  {
-    test_wait_threads();
-    test_assert_sequence("ABCD", "invalid sequence");
-  }
-
-  /* [9.2.6] Testing that the pool contains four elements again.*/
-  test_set_step(6);
-  {
-    for (i = 0; i < 4; i++)
-      test_assert(chPoolAlloc(&mp1) != NULL, "pool list empty");
-    test_assert(chPoolAlloc(&mp1) == NULL, "pool list not empty");
   }
+  test_end_step(1);
 }
 
 static const testcase_t rt_test_009_002 = {
-  "Threads creation from Memory Pool",
+  "Event Flags dispatching",
   rt_test_009_002_setup,
   NULL,
   rt_test_009_002_execute
 };
-#endif /* CH_CFG_USE_MEMPOOLS */
+
+/**
+ * @page rt_test_009_003 [9.3] Events Flags wait using chEvtWaitOne()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtWaitOne() is tested under various scenarios.
+ *
+ * <h2>Test Steps</h2>
+ * - [9.3.1] Setting three event flags.
+ * - [9.3.2] Calling chEvtWaitOne() three times, each time a single
+ *   flag must be returned in order of priority.
+ * - [9.3.3] Getting current time and starting a signaler thread, the
+ *   thread will set an event flag after 50mS.
+ * - [9.3.4] Calling chEvtWaitOne() then verifying that the event has
+ *   been received after 50mS and that the event flags mask has been
+ *   emptied.
+ * .
+ */
+
+static void rt_test_009_003_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void rt_test_009_003_execute(void) {
+  eventmask_t m;
+  systime_t target_time;
+
+  /* [9.3.1] Setting three event flags.*/
+  test_set_step(1);
+  {
+    chEvtAddEvents(7);
+  }
+  test_end_step(1);
+
+  /* [9.3.2] Calling chEvtWaitOne() three times, each time a single
+     flag must be returned in order of priority.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert(m == 1, "single event error");
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert(m == 2, "single event error");
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert(m == 4, "single event error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+  }
+  test_end_step(2);
+
+  /* [9.3.3] Getting current time and starting a signaler thread, the
+     thread will set an event flag after 50mS.*/
+  test_set_step(3);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
+                                   evt_thread3, chThdGetSelfX());
+  }
+  test_end_step(3);
+
+  /* [9.3.4] Calling chEvtWaitOne() then verifying that the event has
+     been received after 50mS and that the event flags mask has been
+     emptied.*/
+  test_set_step(4);
+  {
+    m = chEvtWaitOne(ALL_EVENTS);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    test_assert(m == 1, "event flag error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    test_wait_threads();
+  }
+  test_end_step(4);
+}
+
+static const testcase_t rt_test_009_003 = {
+  "Events Flags wait using chEvtWaitOne()",
+  rt_test_009_003_setup,
+  NULL,
+  rt_test_009_003_execute
+};
+
+/**
+ * @page rt_test_009_004 [9.4] Events Flags wait using chEvtWaitAny()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtWaitAny() is tested under various scenarios.
+ *
+ * <h2>Test Steps</h2>
+ * - [9.4.1] Setting two, non contiguous, event flags.
+ * - [9.4.2] Calling chEvtWaitAny() one time, the two flags must be
+ *   returned.
+ * - [9.4.3] Getting current time and starting a signaler thread, the
+ *   thread will set an event flag after 50mS.
+ * - [9.4.4] Calling chEvtWaitAny() then verifying that the event has
+ *   been received after 50mS and that the event flags mask has been
+ *   emptied.
+ * .
+ */
+
+static void rt_test_009_004_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void rt_test_009_004_execute(void) {
+  eventmask_t m;
+  systime_t target_time;
+
+  /* [9.4.1] Setting two, non contiguous, event flags.*/
+  test_set_step(1);
+  {
+    chEvtAddEvents(5);
+  }
+  test_end_step(1);
+
+  /* [9.4.2] Calling chEvtWaitAny() one time, the two flags must be
+     returned.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitAny(ALL_EVENTS);
+    test_assert(m == 5, "unexpected pending bit");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+  }
+  test_end_step(2);
+
+  /* [9.4.3] Getting current time and starting a signaler thread, the
+     thread will set an event flag after 50mS.*/
+  test_set_step(3);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
+                                   evt_thread3, chThdGetSelfX());
+  }
+  test_end_step(3);
+
+  /* [9.4.4] Calling chEvtWaitAny() then verifying that the event has
+     been received after 50mS and that the event flags mask has been
+     emptied.*/
+  test_set_step(4);
+  {
+    m = chEvtWaitAny(ALL_EVENTS);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    test_assert(m == 1, "event flag error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    test_wait_threads();
+  }
+  test_end_step(4);
+}
+
+static const testcase_t rt_test_009_004 = {
+  "Events Flags wait using chEvtWaitAny()",
+  rt_test_009_004_setup,
+  NULL,
+  rt_test_009_004_execute
+};
+
+/**
+ * @page rt_test_009_005 [9.5] Events Flags wait using chEvtWaitAll()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtWaitAll() is tested under various scenarios.
+ *
+ * <h2>Test Steps</h2>
+ * - [9.5.1] Setting two, non contiguous, event flags.
+ * - [9.5.2] Calling chEvtWaitAll() one time, the two flags must be
+ *   returned.
+ * - [9.5.3] Setting one event flag.
+ * - [9.5.4] Getting current time and starting a signaler thread, the
+ *   thread will set another event flag after 50mS.
+ * - [9.5.5] Calling chEvtWaitAll() then verifying that both event
+ *   flags have been received after 50mS and that the event flags mask
+ *   has been emptied.
+ * .
+ */
+
+static void rt_test_009_005_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void rt_test_009_005_execute(void) {
+  eventmask_t m;
+  systime_t target_time;
+
+  /* [9.5.1] Setting two, non contiguous, event flags.*/
+  test_set_step(1);
+  {
+    chEvtAddEvents(5);
+  }
+  test_end_step(1);
+
+  /* [9.5.2] Calling chEvtWaitAll() one time, the two flags must be
+     returned.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitAll(5);
+    test_assert(m == 5, "unexpected pending bit");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+  }
+  test_end_step(2);
+
+  /* [9.5.3] Setting one event flag.*/
+  test_set_step(3);
+  {
+    chEvtAddEvents(4);
+  }
+  test_end_step(3);
+
+  /* [9.5.4] Getting current time and starting a signaler thread, the
+     thread will set another event flag after 50mS.*/
+  test_set_step(4);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
+                                   evt_thread3, chThdGetSelfX());
+  }
+  test_end_step(4);
+
+  /* [9.5.5] Calling chEvtWaitAll() then verifying that both event
+     flags have been received after 50mS and that the event flags mask
+     has been emptied.*/
+  test_set_step(5);
+  {
+    m = chEvtWaitAll(5);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    test_assert(m == 5, "event flags error");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    test_wait_threads();
+  }
+  test_end_step(5);
+}
+
+static const testcase_t rt_test_009_005 = {
+  "Events Flags wait using chEvtWaitAll()",
+  rt_test_009_005_setup,
+  NULL,
+  rt_test_009_005_execute
+};
+
+#if (CH_CFG_USE_EVENTS_TIMEOUT) || defined(__DOXYGEN__)
+/**
+ * @page rt_test_009_006 [9.6] Events Flags wait timeouts
+ *
+ * <h2>Description</h2>
+ * Timeout functionality is tested for chEvtWaitOneTimeout(),
+ * chEvtWaitAnyTimeout() and chEvtWaitAllTimeout().
+ *
+ * <h2>Conditions</h2>
+ * This test is only executed if the following preprocessor condition
+ * evaluates to true:
+ * - CH_CFG_USE_EVENTS_TIMEOUT
+ * .
+ *
+ * <h2>Test Steps</h2>
+ * - [9.6.1] The functions are invoked first with TIME_IMMEDIATE
+ *   timeout, the timeout condition is tested.
+ * - [9.6.2] The functions are invoked first with a 50mS timeout, the
+ *   timeout condition is tested.
+ * .
+ */
+
+static void rt_test_009_006_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+}
+
+static void rt_test_009_006_execute(void) {
+  eventmask_t m;
+
+  /* [9.6.1] The functions are invoked first with TIME_IMMEDIATE
+     timeout, the timeout condition is tested.*/
+  test_set_step(1);
+  {
+    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_IMMEDIATE);
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_IMMEDIATE);
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_IMMEDIATE);
+    test_assert(m == 0, "spurious event");
+  }
+  test_end_step(1);
+
+  /* [9.6.2] The functions are invoked first with a 50mS timeout, the
+     timeout condition is tested.*/
+  test_set_step(2);
+  {
+    m = chEvtWaitOneTimeout(ALL_EVENTS, TIME_MS2I(50));
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_MS2I(50));
+    test_assert(m == 0, "spurious event");
+    m = chEvtWaitAllTimeout(ALL_EVENTS, TIME_MS2I(50));
+    test_assert(m == 0, "spurious event");
+  }
+  test_end_step(2);
+}
+
+static const testcase_t rt_test_009_006 = {
+  "Events Flags wait timeouts",
+  rt_test_009_006_setup,
+  NULL,
+  rt_test_009_006_execute
+};
+#endif /* CH_CFG_USE_EVENTS_TIMEOUT */
+
+/**
+ * @page rt_test_009_007 [9.7] Broadcasting using chEvtBroadcast()
+ *
+ * <h2>Description</h2>
+ * Functionality of chEvtBroadcast() is tested.
+ *
+ * <h2>Test Steps</h2>
+ * - [9.7.1] Registering on two event sources associating them with
+ *   flags 1 and 4.
+ * - [9.7.2] Getting current time and starting a broadcaster thread,
+ *   the thread broadcast the first Event Source immediately and the
+ *   other after 50mS.
+ * - [9.7.3] Calling chEvtWaitAll() then verifying that both event
+ *   flags have been received after 50mS and that the event flags mask
+ *   has been emptied.
+ * - [9.7.4] Unregistering from the Event Sources.
+ * .
+ */
+
+static void rt_test_009_007_setup(void) {
+  chEvtGetAndClearEvents(ALL_EVENTS);
+  chEvtObjectInit(&es1);
+  chEvtObjectInit(&es2);
+}
+
+static void rt_test_009_007_execute(void) {
+  eventmask_t m;
+  event_listener_t el1, el2;
+  systime_t target_time;
+
+  /* [9.7.1] Registering on two event sources associating them with
+     flags 1 and 4.*/
+  test_set_step(1);
+  {
+    chEvtRegisterMask(&es1, &el1, 1);
+    chEvtRegisterMask(&es2, &el2, 4);
+  }
+  test_end_step(1);
+
+  /* [9.7.2] Getting current time and starting a broadcaster thread,
+     the thread broadcast the first Event Source immediately and the
+     other after 50mS.*/
+  test_set_step(2);
+  {
+    target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(50));
+    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
+                                   evt_thread7, "A");
+  }
+  test_end_step(2);
+
+  /* [9.7.3] Calling chEvtWaitAll() then verifying that both event
+     flags have been received after 50mS and that the event flags mask
+     has been emptied.*/
+  test_set_step(3);
+  {
+    m = chEvtWaitAll(5);
+    test_assert_time_window(target_time,
+                            chTimeAddX(target_time, ALLOWED_DELAY),
+                            "out of time window");
+    m = chEvtGetAndClearEvents(ALL_EVENTS);
+    test_assert(m == 0, "stuck event");
+    test_wait_threads();
+  }
+  test_end_step(3);
+
+  /* [9.7.4] Unregistering from the Event Sources.*/
+  test_set_step(4);
+  {
+    chEvtUnregister(&es1, &el1);
+    chEvtUnregister(&es2, &el2);
+    test_assert(!chEvtIsListeningI(&es1), "stuck listener");
+    test_assert(!chEvtIsListeningI(&es2), "stuck listener");
+  }
+  test_end_step(4);
+}
+
+static const testcase_t rt_test_009_007 = {
+  "Broadcasting using chEvtBroadcast()",
+  rt_test_009_007_setup,
+  NULL,
+  rt_test_009_007_execute
+};
 
 /****************************************************************************
  * Exported data.
@@ -271,21 +581,24 @@ static const testcase_t rt_test_009_002 = {
  * @brief   Array of test cases.
  */
 const testcase_t * const rt_test_sequence_009_array[] = {
-#if (CH_CFG_USE_HEAP) || defined(__DOXYGEN__)
   &rt_test_009_001,
-#endif
-#if (CH_CFG_USE_MEMPOOLS) || defined(__DOXYGEN__)
   &rt_test_009_002,
+  &rt_test_009_003,
+  &rt_test_009_004,
+  &rt_test_009_005,
+#if (CH_CFG_USE_EVENTS_TIMEOUT) || defined(__DOXYGEN__)
+  &rt_test_009_006,
 #endif
+  &rt_test_009_007,
   NULL
 };
 
 /**
- * @brief   Dynamic threads.
+ * @brief   Event Sources and Event Flags.
  */
 const testsequence_t rt_test_sequence_009 = {
-  "Dynamic threads",
+  "Event Sources and Event Flags",
   rt_test_sequence_009_array
 };
 
-#endif /* CH_CFG_USE_DYNAMIC */
+#endif /* CH_CFG_USE_EVENTS */

test/rt/source/test/rt_test_sequence_011.h

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