/*
* This test tests the wait_for_interrupt() function. The boot process
* creates another process. This process enters a loop. For
* each interation it calls wait_for_interrupt (TIMER_IRQ) to cause
* a short delay before the next interation.
*/
void isr_process(PROCESS self, PARAM param)
{
int ticks;
int i;
unsigned char* screen_base;
kprintf("Process: %s\n", self->name);
kprintf("ABCDEF");
/* screen_base points to the beginning of the string "ABCDEF" */
screen_base = (unsigned char*) 0xb8000 + 4 * 80 * 2;
i = 0;
int j;
for (j = 0; j < 30; j ++) {
ticks = 3;
while (ticks--)
wait_for_interrupt(TIMER_IRQ);
*(screen_base + i * 2) = *(screen_base + i * 2) + 1;
i++;
if (i == 6)
i = 0;
check_sum ++;
}
return_to_boot();
}
void test_dispatcher_4_process_a(PROCESS self, PARAM param)
{
kprintf("Process: %s\n\n", self->name);
kprintf("Param: %d\n", param);
print_all_processes(kernel_window);
if (check_sum != 2)
test_failed(22);
check_sum += 1;
return_to_boot();
}
void test_isr_2_process_2(PROCESS self, PARAM param)
{
/* screen_offset points to the "Z" of process 2 */
MEM_ADDR screen_offset = 0xb8000 + 5 * 160 + 2 * 11;
while (42) {
if (test_isr_2_check_sum == 80000)
return_to_boot();
test_isr_2_check_sum ++;
poke_b(screen_offset, peek_b(screen_offset) + 1);
}
}
void test_dispatcher_5_process_e(PROCESS self, PARAM param)
{
kprintf("\nProcess: %s\n\n", self->name);
if (check_sum != 0)
test_failed(23);
check_sum += 2;
resign();
kprintf("Back to %s", self->name);
if (check_sum != 3)
test_failed(24);
check_sum += 4;
return_to_boot();
}
void test_ipc_3_sender_process(PROCESS self, PARAM param)
{
PORT receiver_port = (PORT) param;
int data1= 42;
int data2= 24;
check_sum += 1;
/*
* send the first message
*/
check_process("Receiver", STATE_RECEIVE_BLOCKED, FALSE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(48);
}
kprintf("%s: sending a message using send()...\n",
self->name);
send(receiver_port, &data1);
if (check_sum != 3)
test_failed(49);
check_sum += 4;
kprintf("%s: received = %d\n", self->name, data1);
if (data1 != 11)
test_failed(41);
/*
* send the second message
*/
kprintf("%s: sending a message using message()...\n",
self->name);
message(receiver_port, &data2);
if (check_sum != 15)
test_failed(54);
kprintf("%s: woken up from message()\n", self->name);
return_to_boot();
}
void test_dispatcher_7_process_d(PROCESS self, PARAM param)
{
kprintf("%s\n", self->name);
if (check_sum != 3)
test_failed(24);
check_sum += 4;
resign();
kprintf("Back to process %s \n", self->name);
if (check_sum != 15)
test_failed(24);
check_sum += 16;
resign();
kprintf("Back to process %s again\n\n", self->name);
if (check_sum != 31)
test_failed(24);
check_sum += 32;
return_to_boot();
}
void test_ipc_2_sender_process(PROCESS self, PARAM param)
{
PORT receiver_port = (PORT) param;
int data1 = 42;
int data2 = 24;
check_sum = 0;
/*
* send first message
*/
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: sending a message using send()...\n",
self->name);
send(receiver_port, &data1);
if (check_sum != 1)
test_failed(37);
kprintf("%s: received data = %d\n", self->name, data1);
if (data1 != 11)
test_failed(42);
/*
* send second message
*/
check_sum += 2;
check_process("Sender", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(39);
}
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
kprintf("%s: sending a message using message()...\n",
self->name);
message(receiver_port, &data2);
if (check_sum != 7)
test_failed(37);
kprintf("%s: woken up from message().\n", self->name);
check_process("Receiver", STATE_READY, TRUE);
if (test_result != 0)
test_failed(test_result);
check_sum += 8;
return_to_boot();
}
void test_ipc_6_receiver(PROCESS self, PARAM param)
{
PORT port1;
PORT port2;
PORT port3;
PROCESS sender_1;
PROCESS sender_2;
PROCESS sender_3;
int second_sender;
int *data1;
int *data2;
int *data3;
check_sum += 1;
port1 = self->first_port;
kprintf("%s: creating port 3 and port 2...\n", self->name);
port3 = create_port();
port2 = create_port();
kprintf("%s: closing port 3 and port 2...\n", self->name);
close_port(port2);
close_port(port3);
check_port(port1, self->name, TRUE);
check_port(port2, self->name, FALSE);
check_port(port3, self->name, FALSE);
if (test_result != 0)
test_failed(test_result);
create_process(test_ipc_6_sender_process_3, 5, (PARAM) port3, "Sender 3");
create_process(test_ipc_6_sender_process_2, 5, (PARAM) port2, "Sender 2");
create_process(test_ipc_6_sender_process_1, 4, (PARAM) port1, "Sender 1");
/*
* receive first message
*/
kprintf("%s: receiving first message...\n", self->name);
data1 = (int*) receive(&sender_1);
kprintf("\n%s: received a message from %s, parameter = %d.\n",
self->name, sender_1->name, * data1);
if (string_compare(sender_1->name, "Sender 2") == 1)
test_failed(60);
if (string_compare(sender_1->name, "Sender 3") == 1)
test_failed(60);
if (string_compare(sender_1->name, "Sender 1") != 1)
test_failed(58);
check_process("Sender 3", STATE_MESSAGE_BLOCKED, FALSE);
check_process("Sender 2", STATE_MESSAGE_BLOCKED, FALSE);
check_process("Sender 1", STATE_REPLY_BLOCKED, FALSE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
/*
* receive second message
*/
kprintf("%s: opening port 2 and port 3...\n", self->name);
open_port(port2);
open_port(port3);
check_sum += 2; // to check that first message is receiverd.
kprintf("%s: receiving second message...\n", self->name);
data2 = (int*) receive (&sender_2);
kprintf("%s: received a message from %s, parameter = %d.\n",
self->name, sender_2->name, * data2);
// second message can be from either sender 2 or sender 3, depending
// on implementation of create_port().
second_sender = 0;
if (string_compare(sender_2->name, "Sender 2") == 1) {
check_process("Sender 2", STATE_READY, TRUE);
check_process("Sender 3", STATE_MESSAGE_BLOCKED, FALSE);
second_sender = 2;
} else if (string_compare(sender_2->name, "Sender 3") == 1) {
check_process("Sender 3", STATE_READY, TRUE);
check_process("Sender 2", STATE_MESSAGE_BLOCKED, FALSE);
second_sender = 3;
} else
test_failed(44);
check_sum += 4; // to check that second message is received.
/*
* receive third message
*/
kprintf("%s: receiving third message...\n", self->name);
data3 = (int*) receive(&sender_3);
kprintf("%s: received a message from %s, parameter = %d.\n",
self->name, sender_3->name, * data3);
if (string_compare(sender_3->name, "Sender 1") == 1)
test_failed(44);
if (second_sender == 2) {
if (string_compare(sender_3->name, "Sender 2") == 1)
test_failed(44);
if (string_compare(sender_3->name, "Sender 3") != 1)
test_failed(58);
} else {
if (string_compare(sender_3->name, "Sender 3") == 1)
test_failed(44);
if (string_compare(sender_3->name, "Sender 2") != 1)
test_failed(58);
}
check_process("Sender 3", STATE_READY, TRUE);
check_process("Sender 2", STATE_READY, TRUE);
check_process("Sender 1", STATE_REPLY_BLOCKED, FALSE);
if (test_result != 0) {
print_all_processes(kernel_window);
test_failed(test_result);
}
check_sum += 8; // to check that third message is received.
return_to_boot();
}
