void test2()
{
const int delays[] = {1, 2, 100, 500, 1000, 2000};
const int num_messages = 6;
int message_num;
int sender_id;
void* message;
message_num = 0;
while (1)
{
message = g_test_fixture.receive_message(&sender_id);
printf_1("Process 2 expected message with delay %i...",
delays[message_num]);
if (((message_envelope*)message)->delay == delays[message_num]) {
printf_0("success.\r\n");
} else {
printf_0("fail.\r\n");
}
message_num++;
if (message_num == num_messages) {
printf_1("Process 2 received %i messages total...success.\r\n",
num_messages);
printf_0(GID"_test: END\r\n");
} else if (message_num > num_messages) {
printf_1("Process 2 received over %i messages total...fail.\r\n",
num_messages);
}
g_test_fixture.release_memory_block(message);
g_test_fixture.release_processor();
}
}
main()
{
printf_1("five = %d\n", 5);
printf_proper("hello\n");
printf_proper("%d %s\n", 2, "yo");
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* Configure hardware */
HardwareConfigure();
/* Main task */
MainTask();
/* Never run to here ! */
printf_1("\r\nMake sure all task done !");
while(1){};
}
/* third party dummy test process 2 */
void test2()
{
int previous_priority;
int current_priority;
rtx_dbug_outs((CHAR *)"rtx_test: test2\r\n");
previous_priority = g_test_fixture.get_process_priority(2);
while (1) {
current_priority = g_test_fixture.get_process_priority(2);
if (previous_priority != current_priority) {
previous_priority = current_priority;
printf_1("PID2 : priority = %i\r\n", previous_priority);
}
g_test_fixture.release_processor();
}
}
void init_memory(void* memory_start) {
int i;
int *current_block;
//
// The head pointer starts at the start of free memory plus
// the space required for all our memory blocks
// Since this is pointer arithmetic, adding 1 adds 4 bytes.
//
mem_end = memory_start;
memory_head = (void*)((int)memory_start + ((NUM_MEM_BLKS-1)*MEM_BLK_SIZE));
#ifdef DEBUG_MEM
printf_1("MEMORY HEAD: %x\n\r", memory_head);
#endif
//
// Iterate through the memory pool and setup the free list.
// The first 4 bytes of each memory block contain the address
// of the next free memory block.
//
current_block = (int*)memory_head;
for (i = 0; i < NUM_MEM_BLKS; i++) {
*current_block = (int)current_block - MEM_BLK_SIZE;
if (i == NUM_MEM_BLKS - 1) {
*current_block = NULL;
break;
}
current_block = (void*)(*current_block);
}
//
// Setup the memory allocation field. Each bit in this field
// represents one block in the pool. A value of 0 means
// the block has not been allocated, 1 means the block has been allocated.
//
memory_alloc_field = 0x00000000;
}
void test_management() {
const int total_tests = 3;
int successes;
int failures;
int sender_id;
int test_case;
int test_result;
message_envelope* message;
successes = 0;
failures = 0;
test_result = 0;
while(1) {
message = (message_envelope*)g_test_fixture.receive_message(&sender_id);
test_case = message->data[0];
test_result = message->data[1];
if (test_case == 1) {
//
// Begin test 2
//
g_test_fixture.set_process_priority(TEST_DELAY_SENDER_PID, 3);
g_test_fixture.set_process_priority(TEST_DELAY_RECEIVER_PID, 3);
g_test_fixture.set_process_priority(TEST_MEMORY_WATCHDOG_PID, 2);
g_test_fixture.set_process_priority(TEST_MEMORY_ALLOCATOR_PID, 2);
g_test_fixture.send_message(TEST_MEMORY_WATCHDOG_PID, message);
} else if (test_case == 2) {
//
// Final test case finished. Release the message block.
//
g_test_fixture.set_process_priority(TEST_MEMORY_WATCHDOG_PID, 3);
g_test_fixture.set_process_priority(TEST_MEMORY_ALLOCATOR_PID, 3);
g_test_fixture.set_process_priority(TEST_ERROR_CHECK_PID, 2);
g_test_fixture.send_message(TEST_ERROR_CHECK_PID, message);
} else if (test_case == 3) {
g_test_fixture.release_memory_block(message);
}
//
// Update failure/success counters
//
if (test_result == TEST_SUCCESS) {
successes++;
printf_1(GID"_test: test %i OK\r\n", test_case);
} else if (test_result == TEST_FAILURE) {
failures++;
printf_1(GID"_test: test %i FAIL\r\n", test_case);
}
//
// See if we are finished the entire suite
//
if ((successes + failures) == total_tests) {
printf_1(GID"_test: %i/3 tests OK\r\n", successes);
printf_1(GID"_test: %i/3 tests FAIL\r\n", failures);
printf_0(GID"_test: END\r\n");
}
#ifdef __DEBUG
printf_1("Got a management message from case: %i\r\n", message->data[0]);
printf_1(" Success code: %i\r\n", test_result);
printf_1(" Successes: %i\r\n", successes);
printf_1(" Failures: %i\r\n", failures);
#endif
}
}
void test_memory_allocator() {
void* blocks[64];
message_envelope* message;
int sender_id;
int i;
int j;
int failures;
//
// This process will allocate as much memory as it can, until it becomes blocked;
//
message = (message_envelope*)g_test_fixture.receive_message(&sender_id);
if (sender_id == TEST_MEMORY_WATCHDOG_PID) {
#ifdef _DEBUG
printf_0(" Allocator running, allocating blocks.\r\n");
#endif
i = 0;
while (memory_blocks_full == 0) {
blocks[i] = g_test_fixture.request_memory_block();
memory_blocks_allocated++;
i++;
#ifdef __DEBUG
printf_1(" Allocated %i blocks total\r\n", memory_blocks_allocated);
#endif
}
#ifdef _DEBUG
printf_0(" Allocator running, cleaning up.\r\n");
#endif
//
// We return here when we got blocked and the watchdog ran and
// released a block. Now we verify we can release all our blocks
// without error.
//
failures = 0;
for (j = 0; j < i; j++) {
#ifdef __DEBUG
printf_1(" Deallocating block %i...", j);
#endif
if (g_test_fixture.release_memory_block(blocks[j]) == RTX_ERROR) {
failures++;
#ifdef __DEBUG
printf_0("fail\r\n");
#endif
}
#ifdef __DEBUG
else {
printf_0("ok\r\n");
}
#endif
}
//
// Test done. Signal either success or failure, depending on how many
// deallocations failed.
//
#ifdef _DEBUG
printf_0(" Allocator done. Signaling success\r\n");
#endif
message->data[0] = 2;
if (failures == 0) {
message->data[1] = TEST_SUCCESS;
} else {
message->data[1] = TEST_FAILURE;
}
g_test_fixture.send_message(TEST_MANAGEMENT_PID, message);
} else {
g_test_fixture.release_memory_block(message);
}
while(1) {
g_test_fixture.release_processor();
}
}
void test_delay_receiver() {
const int delays[] = {1, 10, 100, 500, 1000, 2000};
const int num_messages = 6;
const int expected_successes = 7;
int failed;
int message_num;
int sender_id;
int message_delay;
int successes;
message_envelope* message;
failed = 0;
successes = 0;
message_num = 0;
while (1)
{
if ((message_num < num_messages) && failed == 0) {
message = (message_envelope*)g_test_fixture.receive_message(&sender_id);
#ifdef _DEBUG
printf_1(" Expected message with delay %i...",
delays[message_num]);
#endif
memcpy(&message_delay, message->data, sizeof(message_delay));
if (message_delay == delays[message_num]) {
successes++;
#ifdef _DEBUG
printf_0("ok.\r\n");
#endif
} else {
#ifdef _DEBUG
printf_0("fail.\r\n");
#endif
failed = 1;
message->data[0] = 1;
message->data[1] = TEST_FAILURE;
g_test_fixture.send_message(TEST_MANAGEMENT_PID, message);
}
message_num++;
if (message_num == num_messages) {
successes++;
#ifdef _DEBUG
printf_1(" Received %i messages total...success.\r\n",
num_messages);
#endif
}
if (successes == expected_successes) {
//
// Message the test management process with success
//
#ifdef _DEBUG
printf_0(" Done, sending message to management.\r\n");
#endif
message->data[0] = 1;
message->data[1] = TEST_SUCCESS;
g_test_fixture.send_message(TEST_MANAGEMENT_PID, message);
} else {
g_test_fixture.release_memory_block(message);
}
} else {
g_test_fixture.release_processor();
}
}
g_test_fixture.release_processor();
}
void printf_0(const char* format) {
printf_1(format, 0);
}
void init_processes(VOID* stack_start) {
int* stack_iter;
int i;
//
// Setup null process
// Entry point is defined in system_processes.c
//
init_test_procs();
init_user_procs();
//
// Iterate through all processes and setup their stack and state
//
//
for (i = 0; i < NUM_PROCESSES; i++) {
//
// Setup the process' stack pointer. The stack grows downward,
// so the stack pointer for each process must be set to the end of the
// memory allocated for each process' stack.
//
processes[i].stack = stack_start + processes[i].stack_size;
//
// Setup the process' stack with an exception frame which points
// to the entry point of the process.
//
stack_iter = (int*)processes[i].stack;
//
// Exception frame used to start this process
// See section 11.1.2 of Coldfire Family Programmer's Reference Manual
//
#ifdef INIT_DEBUG
printf_1("SETTING ENTRY FOR %i...", i);
#endif
*(--stack_iter) = (int)processes[i].entry; // PC
if (processes[i].is_i_process) {
*(--stack_iter) = 0x40002700; // SR
} else {
*(--stack_iter) = 0x40002000; // SR
}
#ifdef INIT_DEBUG
printf_0(" done\r\n");
#endif
//
// Save the stack pointer
//
processes[i].stack = (void*)stack_iter;
//
// The process is currently stopped
//
processes[i].state = STATE_STOPPED;
//
// Setup message queue
//
processes[i].messages.head = NULL;
processes[i].messages.tail = NULL;
//
// Update the location of the next stack and move to the next process
//
processes[i].queue = QUEUE_NONE;
stack_start = stack_start + processes[i].stack_size;
}
//
// No process is running
//
running_process = NULL;
}
