自学教程：C++ test_set_step函数代码示例

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 void nil_test_004_001_execute(void) {  systime_t time;  msg_t msg;  /* [4.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);  {    chSysLock();    msg = chThdSuspendTimeoutS(&gtr1, TIME_INFINITE);    chSysUnlock();    test_assert(NULL == gtr1, "not NULL");    test_assert(MSG_OK == msg,"wrong returned message");  }  /* [4.1.2] The function chThdSuspendTimeoutS() is invoked, the thread     is not resumed so a timeout must occur. On return the message and     the state of the reference are tested.*/  test_set_step(2);  {    chSysLock();    time = chVTGetSystemTimeX();    msg = chThdSuspendTimeoutS(&tr1, 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 == tr1, "not NULL");    test_assert(MSG_TIMEOUT == msg, "wrong returned message");  }}

static void test_002_002_execute(void) {  /* 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(&gsem1);    test_assert_lock(chSemGetCounterI(&gsem1) == 0,                     "wrong counter value");    test_assert(MSG_OK == msg,                "wrong returned message");  }  /* 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(&gsem2);    test_assert_lock(chSemGetCounterI(&gsem2) == 0,                     "wrong counter value");    test_assert(MSG_RESET == msg,                "wrong returned message");  }}

static void test_005_003_execute(void) {  systime_t time;  /* [5.3.1] Getting the system time for test duration measurement.*/  test_set_step(1);  {    time = test_wait_tick();  }  /* [5.3.2] The five contenders threads are created and let run     atomically, the goals sequence is tested, the threads must     complete in priority order.*/  test_set_step(2);  {    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-5, thread3LL, 0);    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriorityX()-4, thread3L, 0);    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriorityX()-3, thread3M, 0);    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriorityX()-2, thread3H, 0);    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriorityX()-1, thread3HH, 0);    test_wait_threads();    test_assert_sequence("ABCDE", "invalid sequence");  }  /* [5.3.3] Testing that all threads completed within the specified     time windows (110mS...110mS+ALLOWED_DELAY).*/  test_set_step(3);  {    test_assert_time_window(time + MS2ST(110), time + MS2ST(110) + ALLOWED_DELAY,                            "out of time window");  }}

static void test_005_007_execute(void) {  /* [5.7.1] Starting the five threads with increasing priority, the     threads will queue on the condition variable.*/  test_set_step(1);  {    tprio_t prio = chThdGetPriorityX();    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread6, "E");    threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread6, "D");    threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread6, "C");    threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread6, "B");    threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread6, "A");  }  /* [5.7.2] Atomically signaling the condition variable five times     then waiting for the threads to terminate in priority order, the     order is tested.*/  test_set_step(2);  {    chSysLock();    chCondSignalI(&c1);    chCondSignalI(&c1);    chCondSignalI(&c1);    chCondSignalI(&c1);    chCondSignalI(&c1);    chSchRescheduleS();    chSysUnlock();    test_wait_threads();    test_assert_sequence("ABCDE", "invalid sequence");  }}

static void test_002_003_execute(void) {  systime_t time;  msg_t msg;  /* The function chSemWaitTimeout() is invoked, after return the system     time, the counter and the returned message are tested.*/  test_set_step(1);  {    time = chVTGetSystemTimeX();    msg = chSemWaitTimeout(&sem1, MS2ST(1000));    test_assert_time_window(time + MS2ST(1000),                            time + MS2ST(1000) + 1,                            "out of time window");    test_assert_lock(chSemGetCounterI(&sem1) == 0,                     "wrong counter value");    test_assert(MSG_TIMEOUT == msg,                "wrong timeout message");  }  /* The function chSemWaitTimeout() is invoked, after return the system     time, the counter and the returned message are tested.*/  test_set_step(2);  {    time = chVTGetSystemTimeX();    msg = chSemWaitTimeout(&sem1, MS2ST(1000));    test_assert_time_window(time + MS2ST(1000),                            time + MS2ST(1000) + 1,                            "out of time window");    test_assert_lock(chSemGetCounterI(&sem1) == 0,                     "wrong counter value");    test_assert(MSG_TIMEOUT == msg,                "wrong timeout message");  }}

static void nasa_osal_test_002_002_execute(void) {  /* [2.2.1] OS_QueueGetIdByName() is invoked with queue_id set to     NULL, an error is expected.*/  test_set_step(1);  {    int32 err;    err = OS_QueueGetIdByName(NULL, "queue");    test_assert(err == OS_INVALID_POINTER, "NULL not detected");  }  /* [2.2.2] OS_QueueGetIdByName() is invoked with queue_name set to     NULL, an error is expected.*/  test_set_step(2);  {    int32 err;    err = OS_QueueGetIdByName(&qid, NULL);    test_assert(err == OS_INVALID_POINTER, "NULL not detected");  }  /* [2.2.3] OS_QueueGetIdByName() is invoked with a very long task     name, an error is expected.*/  test_set_step(3);  {    int32 err;    err = OS_QueueGetIdByName(&qid, "very very long queue name");    test_assert(err == OS_ERR_NAME_TOO_LONG, "name limit not detected");  }}

static void test_001_004_execute(void) {  uint32 tid;  /* [1.4.1] Creating a task executing an infinite loop.*/  test_set_step(1);  {    int32 err;    err = OS_TaskCreate(&tid,                        "deletable task",                        test_task_delete,                        (uint32 *)wa_test1,                        sizeof wa_test1,                        TASKS_BASE_PRIORITY,                        0);    test_assert(err == OS_SUCCESS, "deletable task creation failed");  }  /* [1.4.2] Letting the task run for a while then deleting it. A check     is performed on the correct execution of the delete handler.*/  test_set_step(2);  {    int32 err;    (void) OS_TaskDelay(50);    err = OS_TaskDelete(tid);    test_assert(err == OS_SUCCESS, "delete failed");    test_assert_sequence("ABC", "events order violation");  }}

static void test_002_004_execute(void) {  systime_t time;  msg_t msg;  /* 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 = chThdSuspendTimeoutS(&gtr1, TIME_INFINITE);    test_assert(NULL == gtr1,                "not NULL");    test_assert(MSG_OK == msg,                "wrong returned message");  }  /* The function chThdSuspendTimeoutS() is invoked, the thread is     not resumed so a timeout must occur. On return the message     and the state of the reference are tested.*/  test_set_step(2);  {    time = chVTGetSystemTimeX();    msg = chThdSuspendTimeoutS(&tr1, MS2ST(1000));    test_assert_time_window(time + MS2ST(1000),                            time + MS2ST(1000) + 1,                            "out of time window");    test_assert(NULL == tr1,                "not NULL");    test_assert(MSG_TIMEOUT == msg,                "wrong returned message");  }}

static void test_006_001_execute(void) {  thread_t *tp;  msg_t msg;  /* [6.1.1] Starting the messenger thread.*/  test_set_step(1);  {    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() + 1,                                   msg_thread1, chThdGetSelfX());  }  /* [6.1.2] Waiting for four messages then testing the receive     order.*/  test_set_step(2);  {    unsigned i;    for (i = 0; i < 4; i++) {      tp = chMsgWait();      msg = chMsgGet(tp);      chMsgRelease(tp, msg);      test_emit_token(msg);    }    test_wait_threads();    test_assert_sequence("ABCD", "invalid sequence");  }}

static void rt_test_005_001_execute(void) {  /* [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 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 void test_003_001_execute(void) {  systime_t time;  msg_t msg;  /* [3.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);  {    threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()-1, thread1, "A");    chSysLock();    msg = chThdSuspendTimeoutS(&tr1, TIME_INFINITE);    chSysUnlock();    test_assert(NULL == tr1, "not NULL");    test_assert(MSG_OK == msg,"wrong returned message");    test_wait_threads();  }  /* [3.1.2] The function chThdSuspendTimeoutS() is invoked, the thread     is not resumed so a timeout must occur. On return the message and     the state of the reference are tested.*/  test_set_step(2);  {    chSysLock();    time = chVTGetSystemTimeX();    msg = chThdSuspendTimeoutS(&tr1, MS2ST(1000));    chSysUnlock();    test_assert_time_window(time + MS2ST(1000),                            time + MS2ST(1000) + CH_CFG_ST_TIMEDELTA + 1,                            "out of time window");    test_assert(NULL == tr1, "not NULL");    test_assert(MSG_TIMEOUT == msg, "wrong returned message");  }}

static void test_003_004_execute(void) {    uint32 local_tmid;    /* [3.4.1] Retrieving the timer by name.*/    test_set_step(1);    {        int32 err;        err = OS_TimerGetIdByName(&local_tmid, "test timer");        test_assert(err == OS_SUCCESS, "timer not found");    }    /* [3.4.2] Setting up the timer for a 70mS one-shot tick.*/    test_set_step(2);    {        uint32 err;        err = OS_TimerSet(local_tmid, 70000, 0);        test_assert(err == OS_SUCCESS, "timer setup failed");    }    /* [3.4.3] Waiting one second then counting the occurred ticks.*/    test_set_step(3);    {        (void) OS_TaskDelay(1000);        test_assert(cnt == 1, "wrong ticks");    }}

static void test_003_003_execute(void) {    /* [3.3.1] OS_TimerGetIdByName() is invoked with timer_id set to       NULL, an error is expected.*/    test_set_step(1);    {        int32 err;        err = OS_TimerGetIdByName(NULL, "timer");        test_assert(err == OS_INVALID_POINTER, "NULL not detected");    }    /* [3.3.2] OS_TimerGetIdByName() is invoked with timer name set to       NULL, an error is expected.*/    test_set_step(2);    {        int32 err;        err = OS_TimerGetIdByName(&tmid, NULL);        test_assert(err == OS_INVALID_POINTER, "NULL not detected");    }    /* [3.3.3] OS_TimerGetIdByName() is invoked with a very long task       name, an error is expected.*/    test_set_step(3);    {        int32 err;        err = OS_TimerGetIdByName(&tmid, "very very long timer name");        test_assert(err == OS_ERR_NAME_TOO_LONG, "name limit not detected");    }}

static void test_004_006_execute(void) {  /* [4.6.1] OS_BinSemGetIdByName() is invoked with sem_id set to NULL,     an error is expected.*/  test_set_step(1);  {    int32 err;    err = OS_BinSemGetIdByName(NULL, "semaphore");    test_assert(err == OS_INVALID_POINTER, "NULL not detected");  }  /* [4.6.2] OS_BinSemGetIdByName() is invoked with semaphore name set     to NULL, an error is expected.*/  test_set_step(2);  {    int32 err;    err = OS_BinSemGetIdByName(&bsid, NULL);    test_assert(err == OS_INVALID_POINTER, "NULL not detected");  }  /* [4.6.3] OS_BinSemGetIdByName() is invoked with a very long task     name, an error is expected.*/  test_set_step(3);  {    int32 err;    err = OS_BinSemGetIdByName(&bsid, "very very long semaphore name");    test_assert(err == OS_ERR_NAME_TOO_LONG, "name limit not detected");  }}

static void nasa_osal_test_002_004_execute(void) {  uint32 local_qid;  uint32 copied;  char data[MESSAGE_SIZE];  /* [2.4.1] Retrieving the queue by name.*/  test_set_step(1);  {    int32 err;    err = OS_QueueGetIdByName(&local_qid, "test queue");    test_assert(err == OS_SUCCESS, "queue not found");  }  /* [2.4.2] Get operation with a one second timeout, an error is     expected.*/  test_set_step(2);  {    int32 err;    err = OS_QueueGet(qid, data, MESSAGE_SIZE, &copied, OS_Milli2Ticks(1000));    test_assert(err == OS_QUEUE_TIMEOUT, "unexpected error code");  }  /* [2.4.3] Get operation in non-blocking mode, an error is     expected.*/  test_set_step(3);  {    int32 err;    err = OS_QueueGet(qid, data, MESSAGE_SIZE, &copied, OS_CHECK);    test_assert(err == OS_QUEUE_EMPTY, "unexpected error code");  }}

static void test_001_002_execute(void) {  systime_t time;  /* The current system time is read then a sleep is performed for 100 system     ticks and on exit the system time is verified again.*/  test_set_step(1);  {    time = chVTGetSystemTimeX();    chThdSleep(100);    test_assert_time_window(time + 100,                            time + 100 + 1,                            "out of time window");  }  /* 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(100);    test_assert_time_window(time + US2ST(100),                            time + US2ST(100) + 1,                            "out of time window");  }  /* 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(time + MS2ST(100),                            time + MS2ST(100) + 1,                            "out of time window");  }  /* 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(time + S2ST(1),                            time + S2ST(1) + 1,                            "out of time window");  }  test_set_step(5);  {    time = chVTGetSystemTimeX();    chThdSleepUntil(time + 100);    test_assert_time_window(time + 100,                            time + 100 + 1,                            "out of time window");  }}

static void nasa_osal_test_002_003_execute(void) {  uint32 tid;  unsigned i;  /* [2.3.1] Creataing a queue with depth 4 and message size 20.*/  test_set_step(1);  {    int32 err;    err = OS_QueueCreate(&qid, "test queue", 4, MESSAGE_SIZE, 0);    test_assert(err == OS_SUCCESS, "queue creation failed");  }  /* [2.3.2] Creating the writer task.*/  test_set_step(2);  {    int32 err;    err = OS_TaskCreate(&tid,                        "writer task",                        test_task_writer,                        (uint32 *)wa_test1,                        sizeof wa_test1,                        TASKS_BASE_PRIORITY,                        0);    test_assert(err == OS_SUCCESS, "writer task creation failed");  }  /* [2.3.3] Reading messages from the writer task.*/  test_set_step(3);  {    for (i = 0; i < WRITER_NUM_MESSAGES; i++) {      int32 err;      char data[MESSAGE_SIZE];      uint32 copied;      err = OS_QueueGet(qid, data, MESSAGE_SIZE, &copied, OS_Milli2Ticks(200));      test_assert(err == OS_SUCCESS, "timed out");      test_assert(strncmp(data, "Hello World", sizeof (data)) == 0,                  "wrong message");    }  }  /* [2.3.4] Waiting for task termination then checking for errors.*/  test_set_step(4);  {    (void) OS_TaskWait(tid);    tid = 0;    test_assert_sequence("", "queue write errors occurred");  }}

static void test_009_003_execute(void) {  msg_t msg1, msg2;  unsigned i;  /* [9.3.1] Filling the mailbox.*/  test_set_step(1);  {    for (i = 0; i < MB_SIZE; i++) {      msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);      test_assert(msg1 == MSG_OK, "wrong wake-up message");    }  }  /* [9.3.2] Testing chMBPost(), chMBPostI(), chMBPostAhead() and     chMBPostAheadI() timeout.*/  test_set_step(2);  {    msg1 = chMBPost(&mb1, 'X', 1);    test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");    chSysLock();    msg1 = chMBPostI(&mb1, 'X');    chSysUnlock();    test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");    msg1 = chMBPostAhead(&mb1, 'X', 1);    test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");    chSysLock();    msg1 = chMBPostAheadI(&mb1, 'X');    chSysUnlock();    test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");  }  /* [9.3.3] Resetting the mailbox. The mailbox is then returned in     active state.*/  test_set_step(3);  {    chMBReset(&mb1);    chMBResumeX(&mb1);  }  /* [9.3.4] Testing chMBFetch() and chMBFetchI() timeout.*/  test_set_step(4);  {    msg1 = chMBFetch(&mb1, &msg2, 1);    test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");    chSysLock();    msg1 = chMBFetchI(&mb1, &msg2);    chSysUnlock();    test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");  }}

static void test_002_005_execute(void) {  systime_t time;  eventmask_t events;  /* A set of event flags are set on the current thread then the     function chVTGetSystemTimeX() is invoked, the function is supposed to     return immediately because the event flags are already pending,     after return the events mask is tested.*/  test_set_step(1);  {    time = chVTGetSystemTimeX();    chEvtSignalI(chThdGetSelfX(), 0x55);    events = chEvtWaitAnyTimeout(ALL_EVENTS, MS2ST(1000));    test_assert((eventmask_t)0 != events,                "timed out");    test_assert((eventmask_t)0x55 == events,                "wrong events mask");  }  /* The pending event flags mask is cleared then the function     chVTGetSystemTimeX() is invoked, after return the events     mask is tested. The thread is signaled by another thread.*/  test_set_step(2);  {    time = chVTGetSystemTimeX();    chThdGetSelfX()->epmask = 0;    events = chEvtWaitAnyTimeout(ALL_EVENTS, MS2ST(1000));    test_assert((eventmask_t)0 != events,                "timed out");    test_assert((eventmask_t)0x55 == events,                "wrong events mask");  }  /* The function chVTGetSystemTimeX() is invoked, no event can     wakeup the thread, the function must return because timeout.*/  test_set_step(3);  {    chSysLock();    time = chVTGetSystemTimeX();    events = chEvtWaitAnyTimeoutS(0, MS2ST(1000));    chSysUnlock();    test_assert_time_window(time + MS2ST(1000),                            time + MS2ST(1000) + 1,                            "out of time window");    test_assert((eventmask_t)0 == events,                "wrong events mask");  }}

static void test_XXX_001_execute(void) {  /* Step description.*/  test_set_step(1);  {  }}

static void test_005_005_execute(void) {  bool b;  tprio_t prio;  /* [5.5.1] Getting current thread priority for later checks.*/  test_set_step(1);  {    prio = chThdGetPriorityX();  }  /* [5.5.2] Locking the mutex first time, it must be possible because     it is not owned.*/  test_set_step(2);  {    b = chMtxTryLock(&m1);    test_assert(b, "already locked");  }  /* [5.5.3] Locking the mutex second time, it must fail because it is     already owned.*/  test_set_step(3);  {    b = chMtxTryLock(&m1);    test_assert(!b, "not locked");  }  /* [5.5.4] Unlocking the mutex then it must not be owned anymore and     the queue must be empty.*/  test_set_step(4);  {    chMtxUnlock(&m1);    test_assert(m1.owner == NULL, "still owned");    test_assert(queue_isempty(&m1.queue), "queue not empty");  }  /* [5.5.5] Testing that priority has not changed after operations.*/  test_set_step(5);  {    test_assert(chThdGetPriorityX() == prio, "wrong priority level");  }  /* [5.5.6] Testing chMtxUnlockAll() behavior.*/  test_set_step(6);  {    b = chMtxTryLock(&m1);    test_assert(b, "already locked");    b = chMtxTryLock(&m1);    test_assert(!b, "not locked");    chMtxUnlockAll();    test_assert(m1.owner == NULL, "still owned");    test_assert(queue_isempty(&m1.queue), "queue not empty");  }  /* [5.5.7] Testing that priority has not changed after operations.*/  test_set_step(7);  {    test_assert(chThdGetPriorityX() == prio, "wrong priority level");  }}

static void test_005_003_execute(void) {  /* [5.3.1] Trying to allocate with 100mS timeout, must fail because     the pool is empty.*/  test_set_step(1);  {    test_assert(chGuardedPoolAllocTimeout(&gmp1, MS2ST(100)) == NULL, "list not empty");  }}

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.*/  test_set_step(1);  {    msg = chSemWaitTimeout(&sem1, TIME_IMMEDIATE);    test_assert(msg == MSG_TIMEOUT, "wrong wake-up message");    test_assert(queue_isempty(&sem1.queue), "queue not empty");    test_assert(sem1.cnt == 0, "counter not zero");  }  /* [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");  }  /* [5.3.3] Testing timeout condition.*/  test_set_step(3);  {    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 void test_002_002_execute(void) {  /* [2.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");  }  /* [2.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");  }  /* [2.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");  }}

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);    chSchRescheduleS();    chSysUnlock();    test_wait_threads();    test_assert_lock(chSemGetCounterI(&sem1) == 1, "invalid counter");    test_assert_sequence("A", "invalid sequence");  }}

static void test_006_002_execute(void) {  /* OS_MutSemGive() is invoked with sem_id set to -1, an error is     expected.*/  test_set_step(1);  {    int32 err;    err = OS_MutSemGive((uint32)-1);    test_assert(err == OS_ERR_INVALID_ID, "invalid sem_id not detected");  }}

static void test_004_007_execute(void) {  /* [4.7.1] OS_BinSemTimedWait() is invoked with timeout set to one     second, an error is expected.*/  test_set_step(1);  {    int32 err;    err = OS_BinSemTimedWait(bsid, 1000);    test_assert(err == OS_SEM_TIMEOUT, "unexpected error code");  }}

static void test_004_004_execute(void) {  /* [4.4.1] OS_BinSemTake() is invoked with sem_id set to -1, an error     is expected.*/  test_set_step(1);  {    int32 err;    err = OS_BinSemTake((uint32)-1);    test_assert(err == OS_ERR_INVALID_ID, "invalid sem_id not detected");  }}