void test_dispatcher_7_process_e(PROCESS self, PARAM param) { kprintf("%s\n", self->name); if (check_sum != 1) test_failed(23); check_sum += 2; remove_ready_queue(self); check_num_proc_on_ready_queue(3); if (test_result != 0) test_failed(test_result); resign(); test_failed(26); }
/* * This test creates a sender and a receiver process. The sender process * has the higher priority and will be scheduled first. * The execution sequence is as follow: * 1. The sender executes a send(). Since the receiver is not RECEIVE_BLOCKED, * the sender will be SEND_BLOCKED. * 2. Execution resumes with the receiver. The receiver executes a receive(), * which will return immediately, and change the sender to state * REPLY_BLOCKED. * 3. The receivers does a reply(), and put the sender back on the ready queue. * The resign() in the reply() will therefore transfer the control back to * the sender. * 4. The sender executes a message(). Since the receiver is not * RECEIVE_BLOCKED, the sender will be MESSAGE_BLOCKED. * 5. Execution resumes with the receiver. The receiver executes a receive(), * which will return immediately, and change the sender to STATE_READY. * 6. The receiver does a resign() and pass the execution back to the sender. * This test send() and message() in the case that the receiver is not * ready to receive. It also test receive() in the case that there are messages * pending. */ void test_ipc_2 () { PORT new_port; test_reset(); new_port = create_process (test_ipc_2_receiver_process, 5, 0, "Receiver"); create_process (test_ipc_2_sender_process, 6, (PARAM) new_port, "Sender"); check_num_proc_on_ready_queue(3); check_process("Sender", STATE_READY, TRUE); check_process("Receiver", STATE_READY, TRUE); if (test_result != 0) test_failed(test_result); resign(); }
void test_dispatcher_4_process_c(PROCESS self, PARAM param) { kprintf("\nProcess: %s\n\n", self->name); print_all_processes(kernel_window); kprintf("\n"); if (check_sum != 0) test_failed(22); check_sum += 2; remove_ready_queue(active_proc); check_num_proc_on_ready_queue(2); if (test_result != 0) test_failed(test_result); resign(); test_failed(26); }
/* * We don't explicitly create a new process, but because of init_process() * and init_dispatcher(), the main thread should be initialized as a process * and be added to the ready queue. * This also test print_all_processes() */ void test_create_process_1() { test_reset(); print_all_processes(kernel_window); //check if the boot process is initialized correctly. check_create_process(boot_name, 1, NULL, 0); if (test_result != 0) test_failed(test_result); check_num_of_pcb_entries(1); if (test_result != 0) test_failed(test_result); check_process(boot_name, STATE_READY, TRUE); if (test_result != 0) test_failed(test_result); check_num_proc_on_ready_queue(1); if (test_result != 0) test_failed(test_result); }
/* * This test creates three processes with the same priority. * The execution sequence is as following: * 1. After the boot process resign(), process F (test_process_f)is executed. * 2. Process F resign, process E (test_process_e) is then executed. * 3. Process E remove itself from the ready queue and then resign, process D * (test_process_d) is then executed. * 4. Process D resign(), process F is then executed. * 5. Process F remove itself from ready queue and then resign. Process D is * the next to be executed since Process E is off ready queue. * 6. Process D resign, the next to be executed is still process D since both * process F and E are off ready queue. * * The execution sequence should be: boot -> F -> E -> D -> F -> D -> D */ void test_dispatcher_7() { test_reset(); create_process(test_dispatcher_7_process_f, 5, 0, "Test process F"); kprintf("Created process F\n"); create_process(test_dispatcher_7_process_e, 5, 0, "Test process E"); kprintf("Created process E\n"); create_process(test_dispatcher_7_process_d, 5, 0, "Test process D"); kprintf("Created process D\n"); kprintf("\n"); check_num_proc_on_ready_queue(4); if (test_result != 0) test_failed(test_result); check_sum = 0; resign(); if(check_sum == 0) test_failed(21); if (check_sum != 63) test_failed(25); }