From ca9f458a7e11e1f3fecec5b96d3e97fb4fcc2b63 Mon Sep 17 00:00:00 2001
From: Quentin Legot <legotquentin@gmail.com>
Date: Wed, 22 Mar 2023 15:52:48 +0100
Subject: [PATCH 1/2] Add test module to tm

---
 src/kernel/thread_manager.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs
index f5368cf..fc0a614 100644
--- a/src/kernel/thread_manager.rs
+++ b/src/kernel/thread_manager.rs
@@ -189,4 +189,11 @@ impl ThreadManager {
         self.g_thread_to_be_destroyed = thread
     }
 
+}
+
+#[cfg(test)]
+mod test {
+
+    
+
 }
\ No newline at end of file

From 21a0da8f242caaa71c9a967dff2e39453428fefb Mon Sep 17 00:00:00 2001
From: Samy Solhi <samy.solhi@etudiant.univ-rennes1.fr>
Date: Wed, 22 Mar 2023 16:20:53 +0100
Subject: [PATCH 2/2] Removed unwraps in synch.rs

---
 src/kernel/synch.rs | 37 +++++++++++++++++++++----------------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/src/kernel/synch.rs b/src/kernel/synch.rs
index 83345f6..8eb4a39 100644
--- a/src/kernel/synch.rs
+++ b/src/kernel/synch.rs
@@ -5,7 +5,6 @@ use crate::simulator::machine::Machine;
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use super::system::System;
 use super::thread_manager::ThreadManager;
 
 ///     Structure of a Semaphore used for synchronisation
@@ -69,8 +68,9 @@ impl Semaphore {
     pub fn v(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager){
         let old_status = machine.interrupt.set_status(InterruptOff);
         self.counter += 1;
-        if self.waiting_queue.peek() != None {
-            thread_manager.ready_to_run(self.waiting_queue.pop().unwrap());
+        match self.waiting_queue.pop() {
+            Some(thread) => thread_manager.ready_to_run(thread),
+            None => ()
         }
         machine.interrupt.set_status(old_status);
     }
@@ -149,17 +149,20 @@ impl Lock {
         let old_status = machine.interrupt.set_status(InterruptOff);
         
         match thread_manager.get_g_current_thread() {
-            Some(thread) => {
+            Some(_) => {
                 if self.held_by_current_thread(thread_manager) {
-                    if self.waiting_queue.peek() != None {
-                        self.owner = Some(self.waiting_queue.pop().unwrap());
-                        match &self.owner {
-                            Some(x) => thread_manager.ready_to_run(Rc::clone(&x)),
-                            None => ()
+                    match self.waiting_queue.pop() {
+                        Some(thread) => {
+                            self.owner = Some(thread);
+                            match &self.owner {
+                                Some(x) => thread_manager.ready_to_run(Rc::clone(&x)),
+                                None => ()
+                            }
+                        },
+                        None => {
+                            self.free = true;
+                            self.owner = None;
                         }
-                    } else {
-                        self.free = true;
-                        self.owner = None;
                     }
                 }
             }
@@ -229,8 +232,9 @@ impl Condition {
     pub fn signal(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager) {
         let old_status = machine.interrupt.set_status(InterruptOff);
 
-        if self.waiting_queue.peek() != None {
-            thread_manager.ready_to_run(self.waiting_queue.pop().unwrap());
+        match self.waiting_queue.pop() {
+            Some(thread) => thread_manager.ready_to_run(thread),
+            None => ()
         }
 
         machine.interrupt.set_status(old_status);
@@ -246,8 +250,9 @@ impl Condition {
     pub fn broadcast(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager) {
         let old_status = machine.interrupt.set_status(InterruptOff);
 
-        while self.waiting_queue.peek() != None {
-            thread_manager.ready_to_run(self.waiting_queue.pop().unwrap());
+        match self.waiting_queue.pop() {
+            Some(thread) => thread_manager.ready_to_run(thread),
+            None => ()
         }
         machine.interrupt.set_status(old_status);