* Test: Verify periodic timer creation. * * Creates a periodic timer that delivers multiple notifications. * Tests: * - Periodic timer creation wi

Test 4: pthread_attr operations */

Test 9: Condition variable basic wait/signal */

Test 10: Condition variable broadcast */

Test 12: pthread_cond_timedwait - timeout */

Test 1: pthread_create and pthread_join */

Test 2: pthread_detach */

Test 5: pthread_mutex basic operations */

Test 8: Mutex ownership errors and deadlock detection */

Test 6: pthread_mutex recursive */

Test 7: pthread_mutex stress test - single thread version */

Test 11: pthread_mutex_timedlock - basic functionality */

Test 3: pthread_self and pthread_equal */

Test 13: pthread_spin_init/destroy - basic operations */

Test 16: pthread_spin_destroy - error cases */

Test 14: pthread_spin_lock/unlock - basic locking */

Test 15: pthread_spin_trylock - non-blocking acquire */

* Test: PTS with Priority Inheritance (ThreadX-compatible semantics) * * Validates that PTS threshold interacts correctly with priority inheritance.

* Test: PTS Reduces Context Switches (ThreadX-compatible semantics) * * Validates that preemption threshold reduces unnecessary preemptions. * Lowe

* Test: PTS Threshold Bounds Checking (ThreadX-compatible semantics) * * Validates PTS threshold constraints: * 1. Threshold must be within valid

* Test: PTS Threshold Validation (ThreadX-compatible semantics) * * Validates that preemption threshold can be set within valid range. * Threshold

* Test: Idle Thread Fallback * * Validates the queue invariant: idle thread (priority 31) is always * runnable, ensuring schedule_select() never fa

* Test: IPC Priority Boost (S6 - Priority Inheritance) * * From the paper's property S6: * "A low-priority task must inherit priorities when its

* Test: Liveness Property (No Starvation) * * From the paper's LTL formula: * []<>SysTick -> ([]<>Task1 /\ []<>Task2 /\ ... /\ []<>TaskN) * * "

* Test: Round-Robin Yield Mechanism * * Validates the round-robin component of the scheduler. * L4_Yield rotates the current thread to the back of

* Test: Schedule Syscall Path * * Validates L4_Set_Priority syscall reaches the kernel and returns. * This exercises the full syscall path: user ->

* Test: Yield Returns Control * * Validates sched_yield() implementation: * 1. Rotates thread to back of priority queue * 2. Returns control (

Test 4: sem_getvalue */

Test 1: sem_init and sem_destroy */

Test 6: Multiple producers and consumers */

Test 8: sem_post overflow handling (POSIX SEM_VALUE_MAX compliance) * * POSIX requires sem_post to return EOVERFLOW when the semaphore value * woul

Test 2: sem_post and sem_wait */

Test 5: Producer-Consumer pattern */

Test 3: sem_trywait - uses static semaphore to avoid register clobbering * * Local variables on the stack have addresses computed from frame/stack

Test 7: Blocking sem_wait test - verifies actual blocking semantics * * This test creates a waiter thread that blocks on a zero-count semaphore. *

Test 2: Thread configuration (pager, scheduler) */

Test 1: Basic thread creation */

Test 3: Thread deletion */

Test 5: Invalid thread operations */

Test 6: Preemption control */

Test 4: UTCB area configuration */

* Test: Verify L4_MyGlobalId() matches L4_Myself(). */

* Test: Verify L4_Pager() returns valid pager thread. */

* Thread Priority Test * * Verify thread priority can be set and queried. * Tests the schedule syscall with valid priority values. */

* Test: Verify L4_Myself() returns valid thread ID. */

* Thread Yield Test * * Verify L4_Yield doesn't crash and returns control. */

* Test: Verify L4_TimePeriod() creates valid time values. */

* Test: Verify L4_Sleep() returns without error. * Note: We don't test timing accuracy since QEMU timing is unreliable. */

* Timer Zero Sleep Test * * Test L4_Sleep with various time values. * Should return without hanging. */

Called from user thread */

Kernel has no fake context, instead of that we rewind * stack and reuse it for kernel thread * * Stack will be created after first interrupt */

Make sender runnable, restoring base priority. * IPC senders should not retain receiver's priority boost. */

* Insert thread into thread map */

Switch context */

* Attempt to write to code memory. * This should trigger an MPU fault since code is execute-only or read-only. */

Check that the QEMU binary supports the requested machine. Exits with a clear error if the machine is not available, which typically means th

Add current thread to waiter list. Returns 0 on success, -1 if full. * Must be called with waiters_lock held. */

Pop first waiter from list. Returns nilthread if list empty. * Must be called with waiters_lock held. */