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 dyn1_execute(void) { size_t n, sz; void *p1; tprio_t prio = chThdGetPriority(); (void)chHeapStatus(&heap1, &sz); /* Starting threads from the heap. */ threads[0] = chThdCreateFromHeap(&heap1, THD_WA_SIZE(THREADS_STACK_SIZE), prio-1, thread, "A"); threads[1] = chThdCreateFromHeap(&heap1, THD_WA_SIZE(THREADS_STACK_SIZE), prio-2, thread, "B"); /* Allocating the whole heap in order to make the thread creation fail.*/ (void)chHeapStatus(&heap1, &n); p1 = chHeapAlloc(&heap1, n); threads[2] = chThdCreateFromHeap(&heap1, THD_WA_SIZE(THREADS_STACK_SIZE), prio-3, thread, "C"); chHeapFree(p1); test_assert(1, (threads[0] != NULL) && (threads[1] != NULL) && (threads[2] == NULL) && (threads[3] == NULL) && (threads[4] == NULL), "thread creation failed"); /* Claiming the memory from terminated threads. */ test_wait_threads(); test_assert_sequence(2, "AB"); /* Heap status checked again.*/ test_assert(3, chHeapStatus(&heap1, &n) == 1, "heap fragmented"); test_assert(4, n == sz, "heap size changed"); }
static void msg1_execute(void) { msg_t msg; /* * Testing the whole messages loop. */ threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority() + 1, thread, chThdSelf()); chMsgRelease(msg = chMsgWait()); test_emit_token(msg); chMsgRelease(msg = chMsgWait()); test_emit_token(msg); chMsgRelease(msg = chMsgWait()); test_emit_token(msg); test_assert_sequence(1, "ABC"); /* * Testing message fetch using chMsgGet(). * Note, the following is valid because the sender has higher priority than * the receiver. */ msg = chMsgGet(); test_assert(1, msg != 0, "no message"); chMsgRelease(0); test_assert(2, msg == 'D', "wrong message"); /* * Must not have pending messages. */ msg = chMsgGet(); test_assert(3, msg == 0, "unknown 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 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 dyn2_execute(void) { int i; tprio_t prio = chThdGetPriority(); /* Adding the WAs to the pool. */ for (i = 0; i < 4; i++) chPoolFree(&mp1, wa[i]); /* Starting threads from the memory pool. */ threads[0] = chThdCreateFromMemoryPool(&mp1, prio-1, thread, "A"); threads[1] = chThdCreateFromMemoryPool(&mp1, prio-2, thread, "B"); threads[2] = chThdCreateFromMemoryPool(&mp1, prio-3, thread, "C"); threads[3] = chThdCreateFromMemoryPool(&mp1, prio-4, thread, "D"); threads[4] = chThdCreateFromMemoryPool(&mp1, prio-5, thread, "E"); test_assert(1, (threads[0] != NULL) && (threads[1] != NULL) && (threads[2] != NULL) && (threads[3] != NULL) && (threads[4] == NULL), "thread creation failed"); /* Claiming the memory from terminated threads. */ test_wait_threads(); test_assert_sequence(2, "ABCD"); /* Now the pool must be full again. */ for (i = 0; i < 4; i++) test_assert(3, chPoolAlloc(&mp1) != NULL, "pool list empty"); test_assert(4, chPoolAlloc(&mp1) == NULL, "pool list not empty"); }
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_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 queues1_execute(void) { unsigned i; size_t n; /* Initial empty state */ test_assert_lock(1, chIQIsEmptyI(&iq), "not empty"); /* Queue filling */ chSysLock(); for (i = 0; i < TEST_QUEUES_SIZE; i++) chIQPutI(&iq, 'A' + i); chSysUnlock(); test_assert_lock(2, chIQIsFullI(&iq), "still has space"); test_assert_lock(3, chIQPutI(&iq, 0) == Q_FULL, "failed to report Q_FULL"); /* Queue emptying */ for (i = 0; i < TEST_QUEUES_SIZE; i++) test_emit_token(chIQGet(&iq)); test_assert_lock(4, chIQIsEmptyI(&iq), "still full"); test_assert_sequence(5, "ABCD"); /* Queue filling again */ chSysLock(); for (i = 0; i < TEST_QUEUES_SIZE; i++) chIQPutI(&iq, 'A' + i); chSysUnlock(); /* Reading the whole thing */ n = chIQReadTimeout(&iq, wa[1], TEST_QUEUES_SIZE * 2, TIME_IMMEDIATE); test_assert(6, n == TEST_QUEUES_SIZE, "wrong returned size"); test_assert_lock(7, chIQIsEmptyI(&iq), "still full"); /* Queue filling again */ chSysLock(); for (i = 0; i < TEST_QUEUES_SIZE; i++) chIQPutI(&iq, 'A' + i); chSysUnlock(); /* Partial reads */ n = chIQReadTimeout(&iq, wa[1], TEST_QUEUES_SIZE / 2, TIME_IMMEDIATE); test_assert(8, n == TEST_QUEUES_SIZE / 2, "wrong returned size"); n = chIQReadTimeout(&iq, wa[1], TEST_QUEUES_SIZE / 2, TIME_IMMEDIATE); test_assert(9, n == TEST_QUEUES_SIZE / 2, "wrong returned size"); test_assert_lock(10, chIQIsEmptyI(&iq), "still full"); /* Testing reset */ chSysLock(); chIQPutI(&iq, 0); chIQResetI(&iq); chSysUnlock(); test_assert_lock(11, chIQGetFullI(&iq) == 0, "still full"); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+1, thread1, NULL); test_assert_lock(12, chIQGetFullI(&iq) == 0, "not empty"); test_wait_threads(); /* Timeout */ test_assert(13, chIQGetTimeout(&iq, 10) == Q_TIMEOUT, "wrong timeout return"); }
static void thd1_execute(void) { threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()-5, thread, "E"); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriority()-4, thread, "D"); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriority()-3, thread, "C"); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriority()-2, thread, "B"); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriority()-1, thread, "A"); test_wait_threads(); test_assert_sequence(1, "ABCDE"); }
static void sem1_execute(void) { threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()+5, thread1, "A"); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriority()+1, thread1, "B"); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriority()+3, thread1, "C"); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriority()+4, thread1, "D"); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriority()+2, thread1, "E"); chSemSignal(&sem1); chSemSignal(&sem1); chSemSignal(&sem1); chSemSignal(&sem1); chSemSignal(&sem1); test_wait_threads(); #if CH_USE_SEMAPHORES_PRIORITY test_assert_sequence(1, "ADCEB"); #else test_assert_sequence(1, "ABCDE"); #endif }
static void mtx8_execute(void) { tprio_t prio = chThdGetPriority(); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread11, "A"); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread10, "C"); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread12, "B"); chCondSignal(&c1); chCondSignal(&c1); test_wait_threads(); test_assert_sequence(1, "ABC"); }
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 mtx2_execute(void) { systime_t time; test_wait_tick(); time = chTimeNow(); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()-1, thread2H, 0); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriority()-2, thread2M, 0); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriority()-3, thread2L, 0); test_wait_threads(); test_assert_sequence(1, "ABC"); test_assert_time_window(2, time + MS2ST(100), time + MS2ST(100) + ALLOWED_DELAY); }
static void mtx7_execute(void) { tprio_t prio = chThdGetPriority(); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread10, "E"); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread10, "D"); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread10, "C"); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread10, "B"); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread10, "A"); chCondBroadcast(&c1); test_wait_threads(); test_assert_sequence(1, "ABCDE"); }
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_005_009_execute(void) { tprio_t prio; /* [5.9.1] Reading current base priority.*/ test_set_step(1); { prio = chThdGetPriorityX(); } /* [5.9.2] Thread A is created at priority P(+1), it locks M2, locks M1 and goes to wait on C1.*/ test_set_step(2); { threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread8, "A"); } /* [5.9.3] Thread C is created at priority P(+2), it enqueues on M1 and boosts TA priority at P(+2).*/ test_set_step(3); { threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread6, "C"); } /* [5.9.4] Thread B is created at priority P(+3), it enqueues on M2 and boosts TA priority at P(+3).*/ test_set_step(4); { threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread9, "B"); } /* [5.9.5] Signaling C1: TA wakes up, unlocks M1 and priority goes to P(+2). TB locks M1, unlocks M1 and completes. TA unlocks M2 and priority goes to P(+1). TC waits on C1. TA completes.*/ test_set_step(5); { chCondSignal(&c1); } /* [5.9.6] Signaling C1: TC wakes up, unlocks M1 and completes.*/ test_set_step(6); { chCondSignal(&c1); } /* [5.9.7] Checking the order of operations.*/ test_set_step(7); { test_wait_threads(); test_assert_sequence("ABC", "invalid sequence"); } }
static void mtx3_execute(void) { systime_t time; test_wait_tick(); time = chTimeNow(); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()-5, thread3LL, 0); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriority()-4, thread3L, 0); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriority()-3, thread3M, 0); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriority()-2, thread3H, 0); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriority()-1, thread3HH, 0); test_wait_threads(); test_assert_sequence(1, "ABCDE"); test_assert_time_window(2, time + MS2ST(110), time + MS2ST(110) + ALLOWED_DELAY); }
static void mtx1_execute(void) { tprio_t prio = chThdGetPriority(); /* Because priority inheritance.*/ chMtxLock(&m1); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread1, "E"); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread1, "D"); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread1, "C"); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread1, "B"); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread1, "A"); chMtxUnlock(); test_wait_threads(); test_assert(1, prio == chThdGetPriority(), "wrong priority level"); test_assert_sequence(2, "ABCDE"); }
static void thd2_execute(void) { threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriority()-4, thread, "D"); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()-5, thread, "E"); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriority()-1, thread, "A"); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriority()-2, thread, "B"); /* Done this way for coverage of chThdCreateI() and chThdResume().*/ chSysLock(); threads[2] = chThdCreateI(wa[2], WA_SIZE, chThdGetPriority()-3, thread, "C"); chSysUnlock(); chThdResume(threads[2]); test_wait_threads(); test_assert_sequence(1, "ABCDE"); }
static void queues2_execute(void) { unsigned i; size_t n; /* Initial empty state */ test_assert_lock(1, chOQIsEmptyI(&oq), "not empty"); /* Queue filling */ for (i = 0; i < TEST_QUEUES_SIZE; i++) chOQPut(&oq, 'A' + i); test_assert_lock(2, chOQIsFullI(&oq), "still has space"); /* Queue emptying */ for (i = 0; i < TEST_QUEUES_SIZE; i++) { char c; chSysLock(); c = chOQGetI(&oq); chSysUnlock(); test_emit_token(c); } test_assert_lock(3, chOQIsEmptyI(&oq), "still full"); test_assert_sequence(4, "ABCD"); test_assert_lock(5, chOQGetI(&oq) == Q_EMPTY, "failed to report Q_EMPTY"); /* Writing the whole thing */ n = chOQWriteTimeout(&oq, wa[1], TEST_QUEUES_SIZE * 2, TIME_IMMEDIATE); test_assert(6, n == TEST_QUEUES_SIZE, "wrong returned size"); test_assert_lock(7, chOQIsFullI(&oq), "not full"); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+1, thread2, NULL); test_assert_lock(8, chOQGetFullI(&oq) == TEST_QUEUES_SIZE, "not empty"); test_wait_threads(); /* Testing reset */ chSysLock(); chOQResetI(&oq); chSysUnlock(); test_assert_lock(9, chOQGetFullI(&oq) == 0, "still full"); /* Partial writes */ n = chOQWriteTimeout(&oq, wa[1], TEST_QUEUES_SIZE / 2, TIME_IMMEDIATE); test_assert(10, n == TEST_QUEUES_SIZE / 2, "wrong returned size"); n = chOQWriteTimeout(&oq, wa[1], TEST_QUEUES_SIZE / 2, TIME_IMMEDIATE); test_assert(11, n == TEST_QUEUES_SIZE / 2, "wrong returned size"); test_assert_lock(12, chOQIsFullI(&oq), "not full"); /* Timeout */ test_assert(13, chOQPutTimeout(&oq, 0, 10) == Q_TIMEOUT, "wrong timeout return"); }
static void mtx6_execute(void) { tprio_t prio = chThdGetPriority(); threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread10, "E"); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread10, "D"); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread10, "C"); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread10, "B"); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread10, "A"); chSysLock(); chCondSignalI(&c1); chCondSignalI(&c1); chCondSignalI(&c1); chCondSignalI(&c1); chCondSignalI(&c1); chSchRescheduleS(); chSysUnlock(); test_wait_threads(); test_assert_sequence(1, "ABCDE"); }
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 evt1_execute(void) { event_listener_t el1, el2; /* * Testing chEvtRegisterMask() and chEvtUnregister(). */ chEvtObjectInit(&es1); chEvtRegisterMask(&es1, &el1, 1); chEvtRegisterMask(&es1, &el2, 2); test_assert(1, chEvtIsListeningI(&es1), "no listener"); chEvtUnregister(&es1, &el1); test_assert(2, chEvtIsListeningI(&es1), "no listener"); chEvtUnregister(&es1, &el2); test_assert(3, !chEvtIsListeningI(&es1), "stuck listener"); /* * Testing chEvtDispatch(). */ chEvtDispatch(evhndl, 7); test_assert_sequence(4, "ABC"); }
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 sem2_execute(void) { int i; systime_t target_time; msg_t msg; /* * Testing special case TIME_IMMEDIATE. */ msg = chSemWaitTimeout(&sem1, TIME_IMMEDIATE); test_assert(1, msg == RDY_TIMEOUT, "wrong wake-up message"); test_assert(2, isempty(&sem1.s_queue), "queue not empty"); test_assert(3, sem1.s_cnt == 0, "counter not zero"); /* * Testing not timeout condition. */ threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority() - 1, thread2, 0); msg = chSemWaitTimeout(&sem1, MS2ST(500)); test_wait_threads(); test_assert(4, msg == RDY_OK, "wrong wake-up message"); test_assert(5, isempty(&sem1.s_queue), "queue not empty"); test_assert(6, sem1.s_cnt == 0, "counter not zero"); /* * Testing timeout condition. */ test_wait_tick(); target_time = chTimeNow() + MS2ST(5 * 500); for (i = 0; i < 5; i++) { test_emit_token('A' + i); msg = chSemWaitTimeout(&sem1, MS2ST(500)); test_assert(7, msg == RDY_TIMEOUT, "wrong wake-up message"); test_assert(8, isempty(&sem1.s_queue), "queue not empty"); test_assert(9, sem1.s_cnt == 0, "counter not zero"); } test_assert_sequence(10, "ABCDE"); test_assert_time_window(11, target_time, target_time + ALLOWED_DELAY); }
static void msg1_execute(void) { thread_t *tp; msg_t msg; /* * Testing the whole messages loop. */ threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() + 1, thread, chThdGetSelfX()); tp = chMsgWait(); msg = chMsgGet(tp); chMsgRelease(tp, msg); test_emit_token(msg); tp = chMsgWait(); msg = chMsgGet(tp); chMsgRelease(tp, msg); test_emit_token(msg); tp = chMsgWait(); msg = chMsgGet(tp); chMsgRelease(tp, msg); test_emit_token(msg); test_assert_sequence(1, "ABC"); }
static void test_005_008_execute(void) { /* [5.8.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.8.2] Broarcasting on the condition variable then waiting for the threads to terminate in priority order, the order is tested.*/ test_set_step(2); { chCondBroadcast(&c1); test_wait_threads(); test_assert_sequence("ABCDE", "invalid sequence"); } }
static void test_005_001_execute(void) { tprio_t prio; /* [5.1.1] Getting the initial priority.*/ test_set_step(1); { prio = chThdGetPriorityX(); } /* [5.1.2] Locking the mutex.*/ test_set_step(2); { chMtxLock(&m1); } /* [5.1.3] Five threads are created that try to lock and unlock the mutex then terminate. The threads are created in ascending priority order.*/ test_set_step(3); { threads[0] = chThdCreateStatic(wa[0], WA_SIZE, prio+1, thread1, "E"); threads[1] = chThdCreateStatic(wa[1], WA_SIZE, prio+2, thread1, "D"); threads[2] = chThdCreateStatic(wa[2], WA_SIZE, prio+3, thread1, "C"); threads[3] = chThdCreateStatic(wa[3], WA_SIZE, prio+4, thread1, "B"); threads[4] = chThdCreateStatic(wa[4], WA_SIZE, prio+5, thread1, "A"); } /* [5.1.4] Unlocking the mutex, the threads will wakeup in priority order because the mutext queue is an ordered one.*/ test_set_step(4); { chMtxUnlock(&m1); test_wait_threads(); test_assert(prio == chThdGetPriorityX(), "wrong priority level"); test_assert_sequence("ABCDE", "invalid sequence"); } }
static void mbox1_execute(void) { msg_t msg1, msg2; unsigned i; /* * Testing initial space. */ test_assert_lock(1, chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size"); /* * Testing enqueuing and backward circularity. */ for (i = 0; i < MB_SIZE - 1; i++) { msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE); test_assert(2, msg1 == MSG_OK, "wrong wake-up message"); } msg1 = chMBPostAhead(&mb1, 'A', TIME_INFINITE); test_assert(3, msg1 == MSG_OK, "wrong wake-up message"); /* * Testing post timeout. */ msg1 = chMBPost(&mb1, 'X', 1); test_assert(4, msg1 == MSG_TIMEOUT, "wrong wake-up message"); chSysLock(); msg1 = chMBPostI(&mb1, 'X'); chSysUnlock(); test_assert(5, msg1 == MSG_TIMEOUT, "wrong wake-up message"); msg1 = chMBPostAhead(&mb1, 'X', 1); test_assert(6, msg1 == MSG_TIMEOUT, "wrong wake-up message"); chSysLock(); msg1 = chMBPostAheadI(&mb1, 'X'); chSysUnlock(); test_assert(7, msg1 == MSG_TIMEOUT, "wrong wake-up message"); /* * Testing final conditions. */ test_assert_lock(8, chMBGetFreeCountI(&mb1) == 0, "still empty"); test_assert_lock(9, chMBGetUsedCountI(&mb1) == MB_SIZE, "not full"); test_assert_lock(10, mb1.rdptr == mb1.wrptr, "pointers not aligned"); /* * Testing dequeuing. */ for (i = 0; i < MB_SIZE; i++) { msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE); test_assert(11, msg1 == MSG_OK, "wrong wake-up message"); test_emit_token(msg2); } test_assert_sequence(12, "ABCDE"); /* * Testing buffer circularity. */ msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE); test_assert(13, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE); test_assert(14, msg1 == MSG_OK, "wrong wake-up message"); test_assert(15, mb1.buffer == mb1.wrptr, "write pointer not aligned to base"); test_assert(16, mb1.buffer == mb1.rdptr, "read pointer not aligned to base"); /* * Testing fetch timeout. */ msg1 = chMBFetch(&mb1, &msg2, 1); test_assert(17, msg1 == MSG_TIMEOUT, "wrong wake-up message"); chSysLock(); msg1 = chMBFetchI(&mb1, &msg2); chSysUnlock(); test_assert(18, msg1 == MSG_TIMEOUT, "wrong wake-up message"); /* * Testing final conditions. */ test_assert_lock(19, chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty"); test_assert_lock(20, chMBGetUsedCountI(&mb1) == 0, "still full"); test_assert_lock(21, mb1.rdptr == mb1.wrptr, "pointers not aligned"); /* * Testing I-Class. */ chSysLock(); msg1 = chMBPostI(&mb1, 'A'); test_assert(22, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostI(&mb1, 'B'); test_assert(23, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostI(&mb1, 'C'); test_assert(24, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostI(&mb1, 'D'); test_assert(25, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostI(&mb1, 'E'); chSysUnlock(); test_assert(26, msg1 == MSG_OK, "wrong wake-up message"); test_assert(27, mb1.rdptr == mb1.wrptr, "pointers not aligned"); for (i = 0; i < MB_SIZE; i++) { chSysLock(); msg1 = chMBFetchI(&mb1, &msg2); chSysUnlock(); test_assert(28, msg1 == MSG_OK, "wrong wake-up message"); test_emit_token(msg2); } test_assert_sequence(29, "ABCDE"); test_assert_lock(30, chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty"); test_assert_lock(31, chMBGetUsedCountI(&mb1) == 0, "still full"); test_assert(32, mb1.rdptr == mb1.wrptr, "pointers not aligned"); chSysLock(); msg1 = chMBPostAheadI(&mb1, 'E'); test_assert(33, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostAheadI(&mb1, 'D'); test_assert(34, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostAheadI(&mb1, 'C'); test_assert(35, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostAheadI(&mb1, 'B'); test_assert(36, msg1 == MSG_OK, "wrong wake-up message"); msg1 = chMBPostAheadI(&mb1, 'A'); chSysUnlock(); test_assert(37, msg1 == MSG_OK, "wrong wake-up message"); test_assert(38, mb1.rdptr == mb1.wrptr, "pointers not aligned"); for (i = 0; i < MB_SIZE; i++) { chSysLock(); msg1 = chMBFetchI(&mb1, &msg2); chSysUnlock(); test_assert(39, msg1 == MSG_OK, "wrong wake-up message"); test_emit_token(msg2); } test_assert_sequence(40, "ABCDE"); test_assert_lock(41, chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty"); test_assert_lock(42, chMBGetUsedCountI(&mb1) == 0, "still full"); test_assert(43, mb1.rdptr == mb1.wrptr, "pointers not aligned"); /* * Testing reset. */ chMBReset(&mb1); /* * Re-testing final conditions. */ test_assert_lock(44, chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty"); test_assert_lock(45, chMBGetUsedCountI(&mb1) == 0, "still full"); test_assert_lock(46, mb1.buffer == mb1.wrptr, "write pointer not aligned to base"); test_assert_lock(47, mb1.buffer == mb1.rdptr, "read pointer not aligned to base"); }