diff --git a/src/tp10/IPriority.java b/src/tp10/IPriority.java
new file mode 100644
index 0000000000000000000000000000000000000000..c055694e0c125ca42b7797a613195415cb74e2c7
--- /dev/null
+++ b/src/tp10/IPriority.java
@@ -0,0 +1,6 @@
+package tp10;
+
+public interface IPriority
+{
+ int getPriority();
+}
diff --git a/src/tp10/IScheduler.java b/src/tp10/IScheduler.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7523bdb1f462292fad5c21e0f84d5989170928a
--- /dev/null
+++ b/src/tp10/IScheduler.java
@@ -0,0 +1,9 @@
+package tp10;
+
+public interface IScheduler<IPriority>
+{
+ void addElement(IPriority type);
+ IPriority highestPriority();
+ boolean isEmpty();
+ int size();
+}
diff --git a/src/tp10/PriorityScheduler.java b/src/tp10/PriorityScheduler.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ef3e0a2685b46a4ae4aa75052e65a471c61606b
--- /dev/null
+++ b/src/tp10/PriorityScheduler.java
@@ -0,0 +1,68 @@
+package tp10;
+
+import java.util.LinkedList;
+
+public class PriorityScheduler<IPriority> implements IScheduler<IPriority>
+{
+ protected LinkedList<Task> theQueue = new LinkedList<>();
+ private int pri;
+
+ public PriorityScheduler(int prio)
+ {
+ this.pri = prio;
+ }
+
+ public int size(int priority)
+ {
+ int nbTask = 0;
+ for(Task t : theQueue)
+ {
+ if(t.getPriority() == priority)
+ {
+ nbTask=nbTask+1;
+ }
+ }
+ return nbTask;
+ }
+
+ @Override
+ public void addElement(IPriority type)
+ {
+ this.theQueue.add((Task) type);
+ }
+
+ @Override
+ public IPriority highestPriority()
+ {
+ int highPrio = 0;
+ for(Task ty : theQueue)
+ {
+ if(ty.getPriority() > highPrio)
+ {
+ highPrio = ty.getPriority();
+ }
+ }
+
+ Task t = null;
+ for(Task ty : theQueue)
+ {
+ if(ty.getPriority() == highPrio)
+ {
+ t = ty;
+ }
+ }
+ return (IPriority) t;
+ }
+
+ @Override
+ public boolean isEmpty()
+ {
+ return theQueue.isEmpty();
+ }
+
+ @Override
+ public int size()
+ {
+ return theQueue.size();
+ }
+}
diff --git a/src/tp10/PrioritySchedulingQueue.java b/src/tp10/PrioritySchedulingQueue.java
new file mode 100644
index 0000000000000000000000000000000000000000..779471e00c5fee14964914e6472139120ef306c0
--- /dev/null
+++ b/src/tp10/PrioritySchedulingQueue.java
@@ -0,0 +1,27 @@
+package tp10;
+
+public class PrioritySchedulingQueue<T extends IPriority> extends SchedulingQueue<T>
+{
+ @Override
+ public T highestPriority()
+ {
+ int highPrio = 0;
+ for(T ty : theQueue)
+ {
+ if(ty.getPriority() > highPrio)
+ {
+ highPrio = ty.getPriority();
+ }
+ }
+
+ T t = null;
+ for(T ty : theQueue)
+ {
+ if(ty.getPriority() == highPrio)
+ {
+ t = ty;
+ }
+ }
+ return t;
+ }
+}
diff --git a/src/tp10/Scheduler.java b/src/tp10/Scheduler.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b60459af3b6c2be10d57dc274194a7a55b09021
--- /dev/null
+++ b/src/tp10/Scheduler.java
@@ -0,0 +1,9 @@
+package tp10;
+
+public class Scheduler
+{
+ void highestPriority()
+ {
+
+ }
+}
\ No newline at end of file
diff --git a/src/tp10/SchedulingQueue.java b/src/tp10/SchedulingQueue.java
new file mode 100644
index 0000000000000000000000000000000000000000..69fd9ba5d36dd2cd85d70bbd5130b0388be1cf54
--- /dev/null
+++ b/src/tp10/SchedulingQueue.java
@@ -0,0 +1,52 @@
+package tp10;
+
+import java.util.LinkedList;
+
+@SuppressWarnings("hiding")
+public class SchedulingQueue<IPriority> implements IScheduler<IPriority>
+{
+ public static int queueCounter;
+ protected LinkedList<IPriority> theQueue = new LinkedList<>();
+
+ public int getID()
+ {
+ return 0;
+ }
+
+ @Override
+ public String toString()
+ {
+ if(theQueue.isEmpty())
+ {
+ return "Queue"+getID()+" -> []";
+ }
+ else
+ {
+ return "Queue"+getID()+" -> "+theQueue.get(getID()).toString();
+ }
+ }
+
+ @Override
+ public void addElement(IPriority type)
+ {
+ theQueue.add(type);
+ }
+
+ @Override
+ public IPriority highestPriority()
+ {
+ return theQueue.getFirst();
+ }
+
+ @Override
+ public boolean isEmpty()
+ {
+ return theQueue.isEmpty();
+ }
+
+ @Override
+ public int size()
+ {
+ return theQueue.size();
+ }
+}
\ No newline at end of file
diff --git a/src/tp10/Task.java b/src/tp10/Task.java
new file mode 100644
index 0000000000000000000000000000000000000000..89e46a4fdb5bbfa550940cc7e412a89cf27cdcaf
--- /dev/null
+++ b/src/tp10/Task.java
@@ -0,0 +1,34 @@
+package tp10;
+
+public class Task implements IPriority
+{
+ int priority;
+ String label;
+
+ public Task(String l, int p)
+ {
+ this.label = l;
+ this.priority = p;
+ }
+
+ public int getPriority()
+ {
+ return this.priority;
+ }
+
+ public String getLabel()
+ {
+ return this.label;
+ }
+
+ public void setLabel(String l)
+ {
+ this.label = l;
+ }
+
+ @Override
+ public String toString()
+ {
+ return "Task:"+getLabel()+"("+getPriority()+")";
+ }
+}
\ No newline at end of file
diff --git a/src/tp10/UsePrioritySchedulingQueue.java b/src/tp10/UsePrioritySchedulingQueue.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a001225691deeb7b88f4760d26f6d76100b6643
--- /dev/null
+++ b/src/tp10/UsePrioritySchedulingQueue.java
@@ -0,0 +1,26 @@
+package tp10;
+
+public class UsePrioritySchedulingQueue
+{
+ public static void main(String[] args)
+ {
+ PrioritySchedulingQueue<Task> tasks = new PrioritySchedulingQueue<>();
+
+ Task t1 = new Task("t1", 3);
+ Task t2 = new Task("t2", 1);
+ Task t3 = new Task("t3", 2);
+ Task t4 = new Task("t4", 5);
+ Task t5 = new Task("t5", 10);
+
+ System.out.println(tasks.isEmpty());
+ tasks.addElement(t1);
+ tasks.addElement(t2);
+ tasks.addElement(t3);
+ tasks.addElement(t4);
+ tasks.addElement(t5);
+ System.out.println(tasks.isEmpty());
+ System.out.println(tasks.size());
+ System.out.println(tasks.highestPriority());
+ System.out.println("\nFinish !");
+ }
+}
\ No newline at end of file
diff --git a/src/tp10/UseSchedulingQueue.java b/src/tp10/UseSchedulingQueue.java
new file mode 100644
index 0000000000000000000000000000000000000000..9950c8332b58f20ae99f3618445c3621415e6cc7
--- /dev/null
+++ b/src/tp10/UseSchedulingQueue.java
@@ -0,0 +1,35 @@
+package tp10;
+
+import tp05.Book;
+
+public class UseSchedulingQueue
+{
+ public static void main(String[] args)
+ {
+ SchedulingQueue<Book> superBook = new SchedulingQueue<>();
+ SchedulingQueue<Task> amongus = new SchedulingQueue<>();
+
+ Book b1 = new Book("pfj", "ao", "zez", 1951, 0);
+ Book b2 = new Book("kko", "ss", "neo", 1985, 0);
+
+ Task t1 = new Task("t1", 3);
+ Task t2 = new Task("t2", 1);
+
+ superBook.addElement(b1);
+ superBook.addElement(b2);
+
+ amongus.addElement(t1);
+ amongus.addElement(t2);
+
+ System.out.println(superBook.isEmpty());
+ System.out.println(amongus.isEmpty());
+ System.out.println(superBook.size());
+ System.out.println(amongus.size());
+
+ System.out.println(superBook);
+ System.out.println(amongus);
+
+ System.out.println(superBook);
+ System.out.println(amongus);
+ }
+}
\ No newline at end of file
diff --git a/test/CompanyTest.java b/test/tp06/CompanyTest.java
similarity index 100%
rename from test/CompanyTest.java
rename to test/tp06/CompanyTest.java
diff --git a/test/BreedingGroundTest.java b/test/tp08/BreedingGroundTest.java
similarity index 99%
rename from test/BreedingGroundTest.java
rename to test/tp08/BreedingGroundTest.java
index 7c4ab87d94fc2c71f8c8640481f2bc167995166b..830a75fdd94ee59be75a272c7d479100345e5e63 100644
--- a/test/BreedingGroundTest.java
+++ b/test/tp08/BreedingGroundTest.java
@@ -1,4 +1,4 @@
-package tpOO.tp08;
+package tp08;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
diff --git a/test/ShopTest.java b/test/tp08/ShopTest.java
similarity index 97%
rename from test/ShopTest.java
rename to test/tp08/ShopTest.java
index f86d050b0a41366600962bb41ea19ae7dbf0e2df..38a1bb737412bf2577f388ce9c577b4cfee36d78 100644
--- a/test/ShopTest.java
+++ b/test/tp08/ShopTest.java
@@ -1,4 +1,4 @@
-package tpOO.tp08;
+package tp08;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -69,7 +69,7 @@ public class ShopTest {
@Test
public void closeBeforeDateTest() {
m.tidy(this.aStock);
- ArrayList<IProduct> res = m.closeBestBeforeDate(-3);
+ ArrayList<Food> res = m.closeBestBeforeDate(-3);
assertEquals(2, res.size());
assertEquals(this.p1, res.get(0));
assertEquals(this.p5, res.get(1));
diff --git a/test/tp10/PrioritySchedulerTest.java b/test/tp10/PrioritySchedulerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd68ea4c1c26972774788e4474b067440c777931
--- /dev/null
+++ b/test/tp10/PrioritySchedulerTest.java
@@ -0,0 +1,148 @@
+package tp10;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class PrioritySchedulerTest {
+ public Task t1, t2, t3, t4, t5;
+ public PriorityScheduler myScheduler;
+ public int width;
+
+ @BeforeEach
+ void initialization() {
+ SchedulingQueue.queueCounter = 0; // reset of automatic numbering from SchedulingQueue
+ width = 4;
+ myScheduler = new PriorityScheduler(width);
+ t1 = new Task("t1", 3);
+ t2 = new Task("t2", 3);
+ t3 = new Task("t3", 1);
+ t4 = new Task("t4", 5);
+ t5 = new Task("t5", 2);
+ }
+
+ @Test
+ void testSize(){
+ assertEquals(0, myScheduler.size()); // empty PriorityScheduler
+ for(int i=0; i<=width+1; i++) assertEquals(0, myScheduler.size(i));
+ myScheduler.addElement(t1); // 1 task, priority 3
+ assertEquals(1, myScheduler.size());
+ for(int i=0; i<=width+1; i++)
+ if(i==3) assertEquals(1, myScheduler.size(i));
+ else assertEquals(0, myScheduler.size(i));
+ myScheduler.addElement(t2); // 2 tasks, same priority
+ assertEquals(2, myScheduler.size());
+ for(int i=0; i<=width+1; i++)
+ if(i==3) assertEquals(2, myScheduler.size(i));
+ else assertEquals(0, myScheduler.size(i));
+ myScheduler.addElement(t3); // 3 tasks, 2 priority values
+ assertEquals(3, myScheduler.size());
+ for(int i=0; i<=width+1; i++)
+ if(i==1) assertEquals(1, myScheduler.size(i));
+ else if(i==3) assertEquals(2, myScheduler.size(i));
+ else assertEquals(0, myScheduler.size(i));
+ myScheduler.addElement(t4); // new task with priority > nbQueue
+ assertEquals(4, myScheduler.size());
+ for(int i=0; i<=width+1; i++)
+ if(i==1) assertEquals(1, myScheduler.size(i));
+ else if(i==3) assertEquals(3, myScheduler.size(i));
+ else assertEquals(0, myScheduler.size(i));
+ }
+
+ @Test
+ void testHighestPriorityTask_noElement() {
+ assertEquals(0, myScheduler.size());
+ assertNull(myScheduler.highestPriority());
+ }
+
+ @Test
+ void testHighestPriorityTask_oneElement() {
+ myScheduler.addElement(t1);
+ assertEquals(1, myScheduler.size());
+ assertEquals(t1, myScheduler.highestPriority());
+ assertEquals(0, myScheduler.size());
+ assertNull(myScheduler.highestPriority());
+ }
+
+ @Test
+ void testHighestPriorityTask_twoElements_samePriority() {
+ myScheduler.addElement(t2);
+ myScheduler.addElement(t1);
+ assertEquals(2, myScheduler.size());
+ assertEquals(t2, myScheduler.highestPriority());
+ assertEquals(1, myScheduler.size());
+ assertEquals(t1, myScheduler.highestPriority());
+ assertEquals(0, myScheduler.size());
+ assertNull(myScheduler.highestPriority());
+ }
+
+ @Test
+ void testHighestPriorityTask_twoElements_nonOrdered() {
+ myScheduler.addElement(t4);
+ myScheduler.addElement(t2);
+ assertEquals(2, myScheduler.size());
+ assertEquals(t4, myScheduler.highestPriority());
+ assertEquals(1, myScheduler.size());
+ assertEquals(t2, myScheduler.highestPriority());
+ assertEquals(0, myScheduler.size());
+ assertNull(myScheduler.highestPriority());
+ }
+
+ @Test
+ void testHighestPriorityTask_threeElements() {
+ myScheduler.addElement(t1);
+ myScheduler.addElement(t3);
+ myScheduler.addElement(t2);
+ assertEquals(3, myScheduler.size());
+ assertEquals(t3, myScheduler.highestPriority());
+ assertEquals(2, myScheduler.size());
+ assertEquals(t1, myScheduler.highestPriority());
+ assertEquals(1, myScheduler.size());
+ assertEquals(t2, myScheduler.highestPriority());
+ assertEquals(0, myScheduler.size());
+ assertNull(myScheduler.highestPriority());
+ }
+
+ @Test
+ void testIsEmptyTask() {
+ assertTrue(myScheduler.isEmpty());
+ assertEquals(0, myScheduler.size());
+ myScheduler.addElement(t1);
+ assertFalse(myScheduler.isEmpty());
+ assertEquals(1, myScheduler.size());
+ assertEquals(t1, myScheduler.highestPriority());
+ assertTrue(myScheduler.isEmpty());
+ assertEquals(0, myScheduler.size());
+ }
+
+ @Test
+ void testToStringTask() {
+ assertEquals(0, myScheduler.size());
+ assertEquals("PriorityQueue:\nQueue0 -> []\nQueue1 -> []\nQueue2 -> []\nQueue3 -> []\n", myScheduler.toString());
+ myScheduler.addElement(t1);
+ assertEquals(1, myScheduler.size());
+ assertEquals("PriorityQueue:\nQueue0 -> []\nQueue1 -> []\nQueue2 -> []\nQueue3 -> [t1(3)]\n", myScheduler.toString());
+ myScheduler.addElement(t2);
+ assertEquals(2, myScheduler.size());
+ assertEquals("PriorityQueue:\nQueue0 -> []\nQueue1 -> []\nQueue2 -> []\nQueue3 -> [t1(3), t2(3)]\n", myScheduler.toString());
+ myScheduler.addElement(t3);
+ assertEquals(3, myScheduler.size());
+ assertEquals("PriorityQueue:\nQueue0 -> []\nQueue1 -> [t3(1)]\nQueue2 -> []\nQueue3 -> [t1(3), t2(3)]\n", myScheduler.toString());
+ }
+
+ class Task implements IPriority{
+ String name;
+ int priority;
+
+ Task(String name, int priority) {
+ this.name = name;
+ this.priority = priority;
+ }
+ public String toString() {return this.name + "(" + this.priority + ")";}
+ public int getPriority() {return this.priority;}
+ }
+}
diff --git a/test/tp10/PrioritySchedulingQueueTest.java b/test/tp10/PrioritySchedulingQueueTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd6ea7fff0c4c7e5b0641d22f8baf6e96da5b3fb
--- /dev/null
+++ b/test/tp10/PrioritySchedulingQueueTest.java
@@ -0,0 +1,116 @@
+package tp10;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class PrioritySchedulingQueueTest {
+ public Task t1, t2, t3;
+ public PrioritySchedulingQueue<Task> orderedTasks;
+
+ @BeforeEach
+ void initialization() {
+ SchedulingQueue.queueCounter = 0;
+ this.orderedTasks = new PrioritySchedulingQueue<>();
+ t1 = new Task("t1", 6);
+ t2 = new Task("t2", 4);
+ t3 = new Task("t3", 2);
+ }
+
+ @Test
+ void testAddElementTask() {
+ assertEquals(0, orderedTasks.size());
+ orderedTasks.addElement(t1);
+ assertEquals(1, orderedTasks.size());
+ orderedTasks.addElement(t2);
+ assertEquals(2, orderedTasks.size());
+ }
+
+ @Test
+ void testHighestPriorityTask_oneElement() {
+ orderedTasks.addElement(t1);
+ assertEquals(1, orderedTasks.size());
+ assertEquals(t1, orderedTasks.highestPriority());
+ assertEquals(0, orderedTasks.size());
+ assertNull(orderedTasks.highestPriority());
+ }
+
+ @Test
+ void testHighestPriorityTask_twoElements_ordered() {
+ orderedTasks.addElement(t2);
+ orderedTasks.addElement(t1);
+ assertEquals(2, orderedTasks.size());
+ assertEquals(t2, orderedTasks.highestPriority());
+ assertEquals(1, orderedTasks.size());
+ assertEquals(t1, orderedTasks.highestPriority());
+ assertEquals(0, orderedTasks.size());
+ assertNull(orderedTasks.highestPriority());
+ }
+
+ @Test
+ void testHighestPriorityTask_twoElements_nonOrdered() {
+ orderedTasks.addElement(t1);
+ orderedTasks.addElement(t2);
+ assertEquals(2, orderedTasks.size());
+ assertEquals(t2, orderedTasks.highestPriority());
+ assertEquals(1, orderedTasks.size());
+ assertEquals(t1, orderedTasks.highestPriority());
+ assertEquals(0, orderedTasks.size());
+ assertNull(orderedTasks.highestPriority());
+ }
+
+ @Test
+ void testHighestPriorityTask_threeElements() {
+ orderedTasks.addElement(t1);
+ orderedTasks.addElement(t3);
+ orderedTasks.addElement(t2);
+ assertEquals(3, orderedTasks.size());
+ assertEquals(t3, orderedTasks.highestPriority());
+ assertEquals(2, orderedTasks.size());
+ assertEquals(t2, orderedTasks.highestPriority());
+ assertEquals(1, orderedTasks.size());
+ assertEquals(t1, orderedTasks.highestPriority());
+ assertEquals(0, orderedTasks.size());
+ assertNull(orderedTasks.highestPriority());
+ }
+
+ @Test
+ void testIsEmptyTask() {
+ assertTrue(orderedTasks.isEmpty());
+ assertEquals(0, orderedTasks.size());
+ orderedTasks.addElement(t1);
+ assertFalse(orderedTasks.isEmpty());
+ assertEquals(1, orderedTasks.size());
+ assertEquals(t1, orderedTasks.highestPriority());
+ assertTrue(orderedTasks.isEmpty());
+ assertEquals(0, orderedTasks.size());
+ }
+
+ @Test
+ void testToStringTask() {
+ assertEquals(0, orderedTasks.size());
+ assertEquals("Queue0 -> []", orderedTasks.toString());
+ orderedTasks.addElement(t1);
+ assertEquals(1, orderedTasks.size());
+ assertEquals("Queue0 -> [t1(6)]", orderedTasks.toString());
+ orderedTasks.addElement(t2);
+ assertEquals(2, orderedTasks.size());
+ assertEquals("Queue0 -> [t2(4), t1(6)]", orderedTasks.toString());
+ }
+
+ class Task implements IPriority{
+ String name;
+ int priority;
+
+ Task(String name, int priority) {
+ this.name = name;
+ this.priority = priority;
+ }
+ public String toString() {return this.name + "(" + this.priority + ")";}
+ public int getPriority() {return this.priority;}
+ }
+}
diff --git a/test/tp10/SchedulingQueueTest.java b/test/tp10/SchedulingQueueTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..81ac07934ef4e4f4472d59fd560e534b29f2a2aa
--- /dev/null
+++ b/test/tp10/SchedulingQueueTest.java
@@ -0,0 +1,185 @@
+package tp10;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.time.LocalDate;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class SchedulingQueueTest {
+ public Book b1, b2;
+ public Task t1, t2;
+ public SchedulingQueue<Book> qBook;
+ public SchedulingQueue<Task> qTask;
+
+ @BeforeEach
+ void initialization() {
+ SchedulingQueue.queueCounter = 0;
+ this.qBook = new SchedulingQueue<>();
+ this.qTask = new SchedulingQueue<>();
+ b1 = new Book("H2G2", "D. Adams", 1979);
+ b2 = new Book("Flatland", "E.Abbott Abbott", 1884);
+ t1 = new Task("a0", 2);
+ t2 = new Task("a1", 4);
+ }
+
+ @Test
+ void testAddElementBook() {
+ assertEquals(0, qBook.size());
+ qBook.addElement(b1);
+ assertEquals(1, qBook.size());
+ qBook.addElement(b2);
+ assertEquals(2, qBook.size());
+ }
+
+ @Test
+ void testHighestPriorityBook() {
+ qBook.addElement(b1);qBook.addElement(b2);
+ assertEquals(2, qBook.size());
+ assertEquals(b1, qBook.highestPriority());
+ assertEquals(1, qBook.size());
+ assertEquals(b2, qBook.highestPriority());
+ assertEquals(0, qBook.size());
+ assertNull(qBook.highestPriority());
+ qBook.addElement(b2);qBook.addElement(b1);
+ assertEquals(2, qBook.size());
+ assertEquals(b2, qBook.highestPriority());
+ assertEquals(1, qBook.size());
+ assertEquals(b1, qBook.highestPriority());
+ assertEquals(0, qBook.size());
+ assertNull(qBook.highestPriority());
+ }
+
+ @Test
+ void testIsEmptyBook() {
+ assertTrue(qBook.isEmpty());
+ assertEquals(0, qBook.size());
+ qBook.addElement(b1);
+ assertFalse(qBook.isEmpty());
+ assertEquals(1, qBook.size());
+ assertEquals(b1, qBook.highestPriority());
+ assertTrue(qBook.isEmpty());
+ assertEquals(0, qBook.size());
+ }
+
+ @Test
+ void testToStringBook() {
+ assertEquals(0, qBook.size());
+ assertEquals("Queue0 -> []", qBook.toString());
+ qBook.addElement(b1);
+ assertEquals(1, qBook.size());
+ assertEquals("Queue0 -> [H2G2:D. Adams(1979)]", qBook.toString());
+ qBook.addElement(b2);
+ assertEquals(2, qBook.size());
+ assertEquals("Queue0 -> [H2G2:D. Adams(1979), Flatland:E.Abbott Abbott(1884)]", qBook.toString());
+ }
+
+ @Test
+ void testAddElementTask() {
+ assertEquals(0, qTask.size());
+ qTask.addElement(t1);
+ assertEquals(1, qTask.size());
+ qTask.addElement(t2);
+ assertEquals(2, qTask.size());
+ }
+
+ @Test
+ void testHighestPriorityTask() {
+ qTask.addElement(t1);qTask.addElement(t2);
+ assertEquals(2, qTask.size());
+ assertEquals(t1, qTask.highestPriority());
+ assertEquals(1, qTask.size());
+ assertEquals(t2, qTask.highestPriority());
+ assertEquals(0, qTask.size());
+ assertNull(qTask.highestPriority());
+ }
+
+ @Test
+ void testIsEmptyTask() {
+ assertTrue(qTask.isEmpty());
+ assertEquals(0, qTask.size());
+ qTask.addElement(t1);
+ assertFalse(qTask.isEmpty());
+ assertEquals(1, qTask.size());
+ assertEquals(t1, qTask.highestPriority());
+ assertTrue(qTask.isEmpty());
+ assertEquals(0, qTask.size());
+ }
+
+ @Test
+ void testToStringTask() {
+ assertEquals(0, qTask.size());
+ assertEquals("Queue1 -> []", qTask.toString());
+ qTask.addElement(t1);
+ assertEquals(1, qTask.size());
+ assertEquals("Queue1 -> [a0:"+LocalDate.now().plusDays(2)+"(2)]", qTask.toString());
+ qTask.addElement(t2);
+ assertEquals(2, qTask.size());
+ assertEquals("Queue1 -> [a0:"+LocalDate.now().plusDays(2)+"(2), a1:" + LocalDate.now().plusDays(4)+"(4)]", qTask.toString());
+ }
+
+ class Task {
+ String name;
+ LocalDate deadline;
+ int duration;
+
+ Task(String name, int duration) {
+ this.name = name;
+ this.deadline = LocalDate.now().plusDays(duration);
+ this.duration = duration;
+ }
+ public String toString() {return this.name + ":" + this.deadline + "(" + this.duration + ")";}
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+ if (obj == null) return false;
+ if (getClass() != obj.getClass()) return false;
+ Task other = (Task) obj;
+ if (!getEnclosingInstance().equals(other.getEnclosingInstance())) return false;
+ if (deadline == null) {
+ if (other.deadline != null) return false;
+ } else if (!deadline.equals(other.deadline)) return false;
+ if (duration != other.duration) return false;
+ if (name == null) {
+ if (other.name != null) return false;
+ } else if (!name.equals(other.name)) return false;
+ return true;
+ }
+ private SchedulingQueueTest getEnclosingInstance() {return SchedulingQueueTest.this;}
+ }
+
+ class Book {
+ String title;
+ String author;
+ int publicationYear;
+ Book(String title, String author, int publicationYear) {
+ this.title = title;
+ this.author = author;
+ this.publicationYear = publicationYear;
+ }
+ public String toString() {
+ return this.title + ":" + this.author + "(" + this.publicationYear + ")";
+ }
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+ if (obj == null) return false;
+ if (getClass() != obj.getClass()) return false;
+ Book other = (Book) obj;
+ if (!getEnclosingInstance().equals(other.getEnclosingInstance())) return false;
+ if (author == null) {
+ if (other.author != null) return false;
+ } else if (!author.equals(other.author)) return false;
+ if (publicationYear != other.publicationYear) return false;
+ if (title == null) {
+ if (other.title != null) return false;
+ } else if (!title.equals(other.title)) return false;
+ return true;
+ }
+ private SchedulingQueueTest getEnclosingInstance() {return SchedulingQueueTest.this;}
+ }
+}
diff --git a/test/tp10/scheduler.log b/test/tp10/scheduler.log
new file mode 100644
index 0000000000000000000000000000000000000000..8930317352546b8e05263fbaac7c1b405e4dd5c4
--- /dev/null
+++ b/test/tp10/scheduler.log
@@ -0,0 +1,102 @@
+IN:DISPLAY:msg0
+IN:DISPLAY:msg1
+IN:LOOP:msg2:4:1
+IN:DYNAMIC:msg3:2:true
+IN:DISPLAY:msg4
+IN:LOOP:msg5:2
+IN:DYNAMIC:msg6:4:true
+IN:DYNAMIC:msg7:1:true:1
+IN:DISPLAY:msg8
+IN:LOOP:msg9:1
+IN:DISPLAY:msg10
+OUT:DYNAMIC:msg3:2:true
+IN:LOOP:msg11:5:1
+IN:DYNAMIC:msg12:5:false:1
+IN:DISPLAY:msg13
+OUT:DYNAMIC:msg6:4:true
+OUT:LOOP:msg2:4:1
+OUT:DYNAMIC:msg7:1:true:1
+OUT:LOOP:msg11:5:1
+OUT:DYNAMIC:msg12:5:false:1
+IN:DISPLAY:msg14
+IN:DISPLAY:msg15
+IN:DISPLAY:msg16
+IN:DISPLAY:msg17:0
+IN:DISPLAY:msg18
+OUT:DISPLAY:msg17:0
+IN:DISPLAY:msg19
+IN:DISPLAY:msg20:2
+IN:DYNAMIC:msg21:4:false:1
+IN:DYNAMIC:msg22:4:false
+IN:DISPLAY:msg23
+OUT:DYNAMIC:msg22:4:false
+IN:DYNAMIC:msg24:4:false
+OUT:DYNAMIC:msg24:4:false
+OUT:DYNAMIC:msg21:4:false:1
+IN:DISPLAY:msg25:0
+IN:DYNAMIC:msg26:4:true
+IN:DISPLAY:msg27:1
+IN:DYNAMIC:msg28:4:false:1
+IN:DYNAMIC:msg29:5:false
+OUT:DISPLAY:msg25:0
+OUT:DYNAMIC:msg26:4:true
+IN:DYNAMIC:msg30:2:false
+OUT:DYNAMIC:msg29:5:false
+IN:LOOP:msg31:5
+IN:LOOP:msg32:3
+OUT:DYNAMIC:msg30:2:false
+IN:DISPLAY:msg33:0
+OUT:DISPLAY:msg33:0
+OUT:DISPLAY:msg27:1
+OUT:DYNAMIC:msg28:4:false:1
+IN:DYNAMIC:msg34:2:false:2
+OUT:LOOP:msg5:2
+OUT:LOOP:msg9:1
+IN:DISPLAY:msg35
+IN:LOOP:msg36:5:3
+IN:LOOP:msg37:2
+IN:DISPLAY:msg38
+OUT:DISPLAY:msg20:2
+OUT:LOOP:msg31:5
+OUT:LOOP:msg32:3
+IN:DYNAMIC:msg39:5:false:3
+OUT:DYNAMIC:msg34:2:false:2
+IN:DYNAMIC:msg40:4:false
+IN:LOOP:msg41:1
+IN:DISPLAY:msg42:0
+IN:DYNAMIC:msg43:1:true
+OUT:DYNAMIC:msg40:4:false
+OUT:DISPLAY:msg42:0
+OUT:DYNAMIC:msg43:1:true
+OUT:LOOP:msg37:2
+IN:LOOP:msg44:3
+IN:DISPLAY:msg45
+IN:DISPLAY:msg46
+OUT:LOOP:msg41:1
+OUT:LOOP:msg44:3
+IN:DISPLAY:msg47:2
+OUT:DISPLAY:msg47:2
+OUT:DISPLAY:msg0
+IN:DISPLAY:msg48
+IN:LOOP:msg49:5
+OUT:LOOP:msg49:5
+IN:LOOP:msg50:2
+OUT:LOOP:msg50:2
+OUT:DISPLAY:msg1
+OUT:DISPLAY:msg4
+OUT:DISPLAY:msg8
+OUT:DISPLAY:msg10
+OUT:DISPLAY:msg13
+OUT:DISPLAY:msg14
+OUT:DISPLAY:msg15
+OUT:DISPLAY:msg16
+OUT:DISPLAY:msg18
+OUT:DISPLAY:msg19
+OUT:DISPLAY:msg23
+OUT:DISPLAY:msg35
+OUT:LOOP:msg36:5:3
+OUT:DISPLAY:msg38
+OUT:DYNAMIC:msg39:5:false:3
+OUT:DISPLAY:msg45
+OUT:DISPLAY:msg46
+OUT:DISPLAY:msg48
diff --git a/test/tp10/schedulerDisplayJobOnly.log b/test/tp10/schedulerDisplayJobOnly.log
new file mode 100644
index 0000000000000000000000000000000000000000..ded59f840033c16560df769f89a363274febac95
--- /dev/null
+++ b/test/tp10/schedulerDisplayJobOnly.log
@@ -0,0 +1,103 @@
+IN:DISPLAY:msg0
+IN:DISPLAY:msg1:1
+IN:DISPLAY:msg2:2
+IN:DISPLAY:msg3:2
+IN:DISPLAY:msg4:0
+IN:DISPLAY:msg5:1
+IN:DISPLAY:msg6:2
+IN:DISPLAY:msg7:2
+IN:DISPLAY:msg8:1
+IN:DISPLAY:msg9:1
+IN:DISPLAY:msg10:0
+OUT:DISPLAY:msg4:0
+OUT:DISPLAY:msg10:0
+IN:DISPLAY:msg11
+OUT:DISPLAY:msg1:1
+OUT:DISPLAY:msg5:1
+OUT:DISPLAY:msg8:1
+OUT:DISPLAY:msg9:1
+OUT:DISPLAY:msg2:2
+IN:DISPLAY:msg12
+OUT:DISPLAY:msg3:2
+IN:DISPLAY:msg13
+IN:DISPLAY:msg14:0
+OUT:DISPLAY:msg14:0
+OUT:DISPLAY:msg6:2
+IN:DISPLAY:msg15:2
+OUT:DISPLAY:msg7:2
+OUT:DISPLAY:msg15:2
+OUT:DISPLAY:msg0
+IN:DISPLAY:msg16:1
+IN:DISPLAY:msg17:0
+IN:DISPLAY:msg18:2
+OUT:DISPLAY:msg17:0
+OUT:DISPLAY:msg16:1
+IN:DISPLAY:msg19:0
+IN:DISPLAY:msg20
+IN:DISPLAY:msg21:0
+IN:DISPLAY:msg22:2
+IN:DISPLAY:msg23:2
+IN:DISPLAY:msg24:2
+OUT:DISPLAY:msg19:0
+IN:DISPLAY:msg25:0
+IN:DISPLAY:msg26
+OUT:DISPLAY:msg21:0
+OUT:DISPLAY:msg25:0
+IN:DISPLAY:msg27
+OUT:DISPLAY:msg18:2
+OUT:DISPLAY:msg22:2
+IN:DISPLAY:msg28:0
+OUT:DISPLAY:msg28:0
+OUT:DISPLAY:msg23:2
+OUT:DISPLAY:msg24:2
+IN:DISPLAY:msg29
+IN:DISPLAY:msg30
+OUT:DISPLAY:msg11
+OUT:DISPLAY:msg12
+IN:DISPLAY:msg31:1
+IN:DISPLAY:msg32:1
+OUT:DISPLAY:msg31:1
+OUT:DISPLAY:msg32:1
+OUT:DISPLAY:msg13
+IN:DISPLAY:msg33:0
+OUT:DISPLAY:msg33:0
+OUT:DISPLAY:msg20
+OUT:DISPLAY:msg26
+OUT:DISPLAY:msg27
+OUT:DISPLAY:msg29
+IN:DISPLAY:msg34:2
+IN:DISPLAY:msg35:2
+IN:DISPLAY:msg36:0
+IN:DISPLAY:msg37:2
+IN:DISPLAY:msg38
+IN:DISPLAY:msg39:0
+OUT:DISPLAY:msg36:0
+IN:DISPLAY:msg40:2
+IN:DISPLAY:msg41
+IN:DISPLAY:msg42
+IN:DISPLAY:msg43:0
+IN:DISPLAY:msg44
+OUT:DISPLAY:msg39:0
+IN:DISPLAY:msg45
+IN:DISPLAY:msg46:2
+OUT:DISPLAY:msg43:0
+OUT:DISPLAY:msg34:2
+IN:DISPLAY:msg47:0
+OUT:DISPLAY:msg47:0
+IN:DISPLAY:msg48:1
+IN:DISPLAY:msg49:0
+OUT:DISPLAY:msg49:0
+IN:DISPLAY:msg50:1
+OUT:DISPLAY:msg48:1
+OUT:DISPLAY:msg50:1
+OUT:DISPLAY:msg35:2
+OUT:DISPLAY:msg37:2
+OUT:DISPLAY:msg40:2
+OUT:DISPLAY:msg46:2
+OUT:DISPLAY:msg30
+OUT:DISPLAY:msg38
+OUT:DISPLAY:msg41
+OUT:DISPLAY:msg42
+OUT:DISPLAY:msg44
+OUT:DISPLAY:msg45
+0