From 1b10d9298ed6b7fcbd96d89db2f7cef5c114d0ba Mon Sep 17 00:00:00 2001
From: MatteoPellegrino05 <matteo1.pellegrino@mail.polimi.it>
Date: Thu, 2 Apr 2026 17:22:18 +0200
Subject: [PATCH 1/3] Fix: OrderTests

---
 .../ingsw/gc14/Model/Orders/Order2Test.java   | 152 ++++++++++-
 .../ingsw/gc14/Model/Orders/Order3Test.java   | 170 +++++++++++-
 .../ingsw/gc14/Model/Orders/Order4Test.java   | 198 ++++++++++++++
 .../ingsw/gc14/Model/Orders/Order5Test.java   | 254 +++++++++++++++++-
 4 files changed, 770 insertions(+), 4 deletions(-)

diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
index d870839..0293699 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
@@ -4,6 +4,9 @@ import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -12,6 +15,9 @@ class Order2Test {
     @Test
     void effectZero() {
         Player p = new Player("p1");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
         Order2 order = new Order2(new ArrayList<>());
 
         int initialFood = p.getFoodValue();
@@ -21,10 +27,26 @@ class Order2Test {
         assertEquals(initialFood + 1, p.getFoodValue());
     }
 
+    @Test
+    void effectZeroWithBuildingEffedt() {
+        Player p = new Player("p1");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
+        Order2 order = new Order2(players);
+
+        int initialFood = p.getFoodValue();
+        order.effect(p, 0);
+        assertTrue(p.getFoodValue() >= initialFood + 1);
+    }
+
     @Test
     void effectOneWithFood() {
         Player p = new Player("p1");
-        Order2 order = new Order2(new ArrayList<>());
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
+        Order2 order = new Order2(players);
 
         p.addFood(1);
         int initialPrestige = p.getPrestigeValue();
@@ -38,7 +60,10 @@ class Order2Test {
     @Test
     void effectOneWithoutFood() {
         Player p = new Player("p1");
-        Order2 order = new Order2(new ArrayList<>());
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
+        Order2 order = new Order2(players);
 
         p.addPrestige(3);
 
@@ -51,6 +76,8 @@ class Order2Test {
     @Test
     void effectWrongIndexHigh() {
         Player p = new Player("p1");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
         Order2 order = new Order2(new ArrayList<>());
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 2));
@@ -59,8 +86,129 @@ class Order2Test {
     @Test
     void effectWrongIndexLow() {
         Player p = new Player("p1");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
         Order2 order = new Order2(new ArrayList<>());
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
     }
+
+    @Test
+    void pullAll() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+
+        Order2 order = new Order2(players);
+
+        Player first = order.pull();
+        Player second = order.pull();
+
+        Set<Player> extracted = new HashSet<>();
+        extracted.add(first);
+        extracted.add(second);
+
+        assertEquals(2, extracted.size());
+        assertTrue(extracted.contains(p1));
+        assertTrue(extracted.contains(p2));
+    }
+
+    @Test
+    void pullEmpty() {
+        Player p = new Player("p1");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+        Order2 order = new Order2(players);
+
+        order.pull();
+
+        assertThrows(NoSuchElementException.class, order::pull);
+    }
+
+    @Test
+    void firstPlayer() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+
+        Order2 order = new Order2(players);
+
+        Player first = order.getFirst();
+
+        assertTrue(first == p1 || first == p2);
+    }
+
+    @Test
+    void pushZero() {
+        ArrayList<Player> players = new ArrayList<>();
+        Order2 order = new Order2(players);
+
+        Player p = new Player("p1");
+        int initialFood = p.getFoodValue();
+
+        order.push(p);
+
+        assertEquals(initialFood + 1, p.getFoodValue());
+        assertEquals(p, order.getFirst());
+    }
+
+    @Test
+    void pushOneFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+
+        Order2 order = new Order2(players);
+
+        p2.addFood(1);
+        int initialPrestige = p2.getPrestigeValue();
+
+        order.push(p2);
+
+        assertEquals(0, p2.getFoodValue());
+        assertEquals(initialPrestige, p2.getPrestigeValue());
+    }
+
+    @Test
+    void pushOneNoFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+
+        Order2 order = new Order2(players);
+
+        p2.addPrestige(3);
+
+        order.push(p2);
+
+        assertEquals(1, p2.getPrestigeValue());
+    }
+
+    @Test
+    void pushFull() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+
+        Order2 order = new Order2(players);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p3));
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java
index fd801b3..a0ece7e 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java
@@ -4,6 +4,9 @@ import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -21,6 +24,18 @@ class Order3Test {
         assertEquals(initialFood + 2, p.getFoodValue());
     }
 
+    @Test
+    void effectZeroWithBuildingEffect() {
+        Player p = new Player("Luca");
+        Order3 order = new Order3(new ArrayList<>());
+
+        int initialFood = p.getFoodValue();
+
+        order.effect(p, 0);
+
+        assertTrue(p.getFoodValue() >= initialFood + 2);
+    }
+
     @Test
     void effectOne() {
         Player p = new Player("Mario");
@@ -77,4 +92,157 @@ class Order3Test {
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
     }
-}
\ No newline at end of file
+
+    @Test
+    void pullAll() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+
+        Order3 order = new Order3(players);
+
+        Player first = order.pull();
+        Player second = order.pull();
+        Player third = order.pull();
+
+        Set<Player> extracted = new HashSet<>();
+        extracted.add(first);
+        extracted.add(second);
+        extracted.add(third);
+
+        assertEquals(3, extracted.size());
+        assertTrue(extracted.contains(p1));
+        assertTrue(extracted.contains(p2));
+        assertTrue(extracted.contains(p3));
+    }
+
+    @Test
+    void pullEmpty() {
+        Player p = new Player("p1");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
+        Order3 order = new Order3(players);
+
+        order.pull();
+
+        assertThrows(NoSuchElementException.class, order::pull);
+    }
+
+    @Test
+    void firstPlayer() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+
+        Order3 order = new Order3(players);
+
+        Player first = order.getFirst();
+
+        assertTrue(first == p1 || first == p2 || first == p3);
+    }
+
+    @Test
+    void pushZero() {
+        ArrayList<Player> players = new ArrayList<>();
+        Order3 order = new Order3(players);
+
+        Player p = new Player("p1");
+        int initialFood = p.getFoodValue();
+
+        order.push(p);
+
+        assertEquals(initialFood + 2, p.getFoodValue());
+        assertEquals(p, order.getFirst());
+    }
+
+    @Test
+    void pushOne() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+
+        Order3 order = new Order3(players);
+
+        int initialFood = p2.getFoodValue();
+        int initialPrestige = p2.getPrestigeValue();
+
+        order.push(p2);
+
+        assertEquals(initialFood, p2.getFoodValue());
+        assertEquals(initialPrestige, p2.getPrestigeValue());
+    }
+
+    @Test
+    void pushTwoFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+
+        Order3 order = new Order3(players);
+
+        p3.addFood(1);
+
+        order.push(p3);
+
+        assertEquals(0, p3.getFoodValue());
+        assertEquals(-2, p3.getPrestigeValue());
+    }
+
+    @Test
+    void pushTwoNoFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+
+        Order3 order = new Order3(players);
+
+        int initialFood = p3.getFoodValue();
+        int initialPrestige = p3.getPrestigeValue();
+
+        order.push(p3);
+
+        assertEquals(initialFood, p3.getFoodValue());
+        assertEquals(initialPrestige, p3.getPrestigeValue());
+    }
+
+    @Test
+    void pushFull() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+
+        Order3 order = new Order3(players);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p4));
+    }
+
+}
+
diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java
index e935965..77f23b3 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java
@@ -4,6 +4,9 @@ import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -21,6 +24,18 @@ class Order4Test {
         assertEquals(initialFood + 2, p.getFoodValue());
     }
 
+    @Test
+    void effectZeroBuild() {
+        Player p = new Player("Luca");
+        Order4 order = new Order4(new ArrayList<>());
+
+        int initialFood = p.getFoodValue();
+
+        order.effect(p, 0);
+
+        assertTrue(p.getFoodValue() >= initialFood + 2);
+    }
+
     @Test
     void effectOne() {
         Player p = new Player("Luca");
@@ -89,4 +104,187 @@ class Order4Test {
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
     }
+
+    @Test
+    void pullAll() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+
+        Order4 order = new Order4(players);
+
+        Player first = order.pull();
+        Player second = order.pull();
+        Player third = order.pull();
+        Player fourth = order.pull();
+
+        Set<Player> extracted = new HashSet<>();
+        extracted.add(first);
+        extracted.add(second);
+        extracted.add(third);
+        extracted.add(fourth);
+
+        assertEquals(4, extracted.size());
+        assertTrue(extracted.contains(p1));
+        assertTrue(extracted.contains(p2));
+        assertTrue(extracted.contains(p3));
+        assertTrue(extracted.contains(p4));
+    }
+
+    @Test
+    void pullEmpty() {
+        Player p = new Player("p1");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
+        Order4 order = new Order4(players);
+
+        order.pull();
+
+        assertThrows(NoSuchElementException.class, order::pull);
+    }
+
+    @Test
+    void firstPlayer() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+
+        Order4 order = new Order4(players);
+
+        Player first = order.getFirst();
+
+        assertTrue(first == p1 || first == p2 || first == p3 || first == p4);
+    }
+
+    @Test
+    void pushZero() {
+        ArrayList<Player> players = new ArrayList<>();
+        Order4 order = new Order4(players);
+
+        Player p = new Player("p1");
+        int initialFood = p.getFoodValue();
+
+        order.push(p);
+
+        assertEquals(initialFood + 2, p.getFoodValue());
+        assertEquals(p, order.getFirst());
+    }
+
+    @Test
+    void pushOne() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+
+        Order4 order = new Order4(players);
+
+        int initialFood = p2.getFoodValue();
+
+        order.push(p2);
+
+        assertEquals(initialFood + 1, p2.getFoodValue());
+    }
+
+    @Test
+    void pushTwo() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+
+        Order4 order = new Order4(players);
+
+        int initialFood = p3.getFoodValue();
+        int initialPrestige = p3.getPrestigeValue();
+
+        order.push(p3);
+
+        assertEquals(initialFood, p3.getFoodValue());
+        assertEquals(initialPrestige, p3.getPrestigeValue());
+    }
+
+    @Test
+    void pushThreeFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+
+        Order4 order = new Order4(players);
+
+        p4.addFood(1);
+
+        order.push(p4);
+
+        assertEquals(0, p4.getFoodValue());
+        assertEquals(-2, p4.getPrestigeValue());
+    }
+
+    @Test
+    void pushThreeNoFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+
+        Order4 order = new Order4(players);
+
+        int initialFood = p4.getFoodValue();
+        int initialPrestige = p4.getPrestigeValue();
+
+        order.push(p4);
+
+        assertEquals(initialFood, p4.getFoodValue());
+        assertEquals(initialPrestige, p4.getPrestigeValue());
+    }
+
+    @Test
+    void pushFull() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+
+        Order4 order = new Order4(players);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p5));
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java
index f3678c6..01fbf4f 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java
@@ -4,6 +4,9 @@ import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -22,6 +25,18 @@ class Order5Test {
         assertEquals(0, p.getPrestigeValue());
     }
 
+    @Test
+    void effectZeroBuild() {
+        Player p = new Player("Luca");
+        Order5 order = new Order5(new ArrayList<>());
+
+        int initialFood = p.getFoodValue();
+
+        order.effect(p, 0);
+
+        assertTrue(p.getFoodValue() >= initialFood + 3);
+    }
+
     @Test
     void effectOne() {
         Player p = new Player("Luca");
@@ -106,4 +121,241 @@ class Order5Test {
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
     }
-}
\ No newline at end of file
+
+    @Test
+    void pullAll() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+
+        Order5 order = new Order5(players);
+
+        Player first = order.pull();
+        Player second = order.pull();
+        Player third = order.pull();
+        Player fourth = order.pull();
+        Player fifth = order.pull();
+
+        Set<Player> extracted = new HashSet<>();
+        extracted.add(first);
+        extracted.add(second);
+        extracted.add(third);
+        extracted.add(fourth);
+        extracted.add(fifth);
+
+        assertEquals(5, extracted.size());
+        assertTrue(extracted.contains(p1));
+        assertTrue(extracted.contains(p2));
+        assertTrue(extracted.contains(p3));
+        assertTrue(extracted.contains(p4));
+        assertTrue(extracted.contains(p5));
+    }
+
+    @Test
+    void pullEmpty() {
+        Player p = new Player("p1");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p);
+
+        Order5 order = new Order5(players);
+
+        order.pull();
+
+        assertThrows(NoSuchElementException.class, order::pull);
+    }
+
+    @Test
+    void firstPlayer() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+
+        Order5 order = new Order5(players);
+
+        Player first = order.getFirst();
+
+        assertTrue(first == p1 || first == p2 || first == p3 || first == p4 || first == p5);
+    }
+
+    @Test
+    void pushZero() {
+        ArrayList<Player> players = new ArrayList<>();
+        Order5 order = new Order5(players);
+
+        Player p = new Player("p1");
+        int initialFood = p.getFoodValue();
+
+        order.push(p);
+
+        assertEquals(initialFood + 3, p.getFoodValue());
+        assertEquals(p, order.getFirst());
+    }
+
+    @Test
+    void pushOne() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+
+        Order5 order = new Order5(players);
+
+        int initialFood = p2.getFoodValue();
+
+        order.push(p2);
+
+        assertEquals(initialFood + 1, p2.getFoodValue());
+    }
+
+    @Test
+    void pushTwo() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+
+        Order5 order = new Order5(players);
+
+        int initialFood = p3.getFoodValue();
+        int initialPrestige = p3.getPrestigeValue();
+
+        order.push(p3);
+
+        assertEquals(initialFood, p3.getFoodValue());
+        assertEquals(initialPrestige, p3.getPrestigeValue());
+    }
+
+    @Test
+    void pushThree() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+
+        Order5 order = new Order5(players);
+
+        int initialFood = p4.getFoodValue();
+        int initialPrestige = p4.getPrestigeValue();
+
+        order.push(p4);
+
+        assertEquals(initialFood, p4.getFoodValue());
+        assertEquals(initialPrestige, p4.getPrestigeValue());
+    }
+
+    @Test
+    void pushFourFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+
+        Order5 order = new Order5(players);
+
+        p5.addFood(1);
+
+        order.push(p5);
+
+        assertEquals(0, p5.getFoodValue());
+        assertEquals(-2, p5.getPrestigeValue());
+    }
+
+    @Test
+    void pushFourNoFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+
+        Order5 order = new Order5(players);
+
+        int initialFood = p5.getFoodValue();
+        int initialPrestige = p5.getPrestigeValue();
+
+        order.push(p5);
+
+        assertEquals(initialFood, p5.getFoodValue());
+        assertEquals(initialPrestige, p5.getPrestigeValue());
+    }
+
+    @Test
+    void pushFull() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+        Player p6 = new Player("p6");
+
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+
+        Order5 order = new Order5(players);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p6));
+    }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From a7426f03f7c2e74c19d0cc378d1afd378370f2aa Mon Sep 17 00:00:00 2001
From: MatteoPellegrino05 <matteo1.pellegrino@mail.polimi.it>
Date: Fri, 3 Apr 2026 11:57:33 +0200
Subject: [PATCH 2/3] Fix: Order2Test.java

---
 .../ingsw/gc14/Model/Orders/Order2Test.java   | 286 +++++++-----------
 1 file changed, 115 insertions(+), 171 deletions(-)

diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
index 0293699..c703b13 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
@@ -1,214 +1,158 @@
 package it.polimi.ingsw.gc14.Model.Orders;
 
+import it.polimi.ingsw.gc14.Model.Cards.Building.EffectType;
+import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
-
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.NoSuchElementException;
-import java.util.Set;
-
 import static org.junit.jupiter.api.Assertions.*;
 
 class Order2Test {
 
     @Test
-    void effectZero() {
-        Player p = new Player("p1");
+    void firstReturnGetsFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
         ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
+        players.add(p1);
+        players.add(p2);
+        Order2 order = new Order2(players);
 
-        Order2 order = new Order2(new ArrayList<>());
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
 
-        int initialFood = p.getFoodValue();
+        int initialFood = firstToAct.getFoodValue();
+        order.push(firstToAct);
 
-        order.effect(p, 0);
-
-        assertEquals(initialFood + 1, p.getFoodValue());
+        assertEquals(initialFood + 1, firstToAct.getFoodValue());
+        assertEquals(firstToAct, order.getFirst());
     }
 
     @Test
-    void effectZeroWithBuildingEffedt() {
-        Player p = new Player("p1");
+    void secondReturnPaysFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
         ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
+        players.add(p1);
+        players.add(p2);
+        Order2 order = new Order2(players);
+
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+
+        secondToAct.addFood(1);
+        int initialPrestige = secondToAct.getPrestigeValue();
+
+        order.push(firstToAct);
+        order.push(secondToAct);
+
+        assertEquals(0, secondToAct.getFoodValue());
+        assertEquals(initialPrestige, secondToAct.getPrestigeValue());
+    }
+
+    @Test
+    void secondReturnLosesPrestige() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        Order2 order = new Order2(players);
+
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+
+        secondToAct.addPrestige(3);
+
+        order.push(firstToAct);
+        order.push(secondToAct);
+
+        assertEquals(0, secondToAct.getFoodValue());
+        assertEquals(1, secondToAct.getPrestigeValue());
+    }
+
+    @Test
+    void firstReturnWithBuilding() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        Order2 order = new Order2(players);
+
+        Player firstToAct = order.pull();
+        order.pull();
+
+        firstToAct.buildingCards.add(new BuildingCard(3, 1, 1, 2));
+
+        order.push(firstToAct);
+
+        assertEquals(2, firstToAct.getFoodValue());
+    }
+
+    @Test
+    void thirdPlayerThrows() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        Order2 order = new Order2(players);
+
+        order.pull();
+        order.pull();
+
+        order.push(p1);
+        order.push(p2);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p3));
+    }
+
+    @Test
+    void constructorLoadsPlayers() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
 
         Order2 order = new Order2(players);
 
-        int initialFood = p.getFoodValue();
-        order.effect(p, 0);
-        assertTrue(p.getFoodValue() >= initialFood + 1);
+        Player firstOut = order.pull();
+        Player secondOut = order.pull();
+
+        assertTrue((firstOut == p1 && secondOut == p2) || (firstOut == p2 && secondOut == p1));
+        assertThrows(NoSuchElementException.class, order::pull);
     }
 
     @Test
-    void effectOneWithFood() {
+    void wrongIndexLow() {
         Player p = new Player("p1");
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-
-        Order2 order = new Order2(players);
-
-        p.addFood(1);
-        int initialPrestige = p.getPrestigeValue();
-
-        order.effect(p, 1);
-
-        assertEquals(0, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectOneWithoutFood() {
-        Player p = new Player("p1");
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-
-        Order2 order = new Order2(players);
-
-        p.addPrestige(3);
-
-        order.effect(p, 1);
-
-        assertEquals(0, p.getFoodValue());
-        assertEquals(1, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectWrongIndexHigh() {
-        Player p = new Player("p1");
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-        Order2 order = new Order2(new ArrayList<>());
-
-        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 2));
-    }
-
-    @Test
-    void effectWrongIndexLow() {
-        Player p = new Player("p1");
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-
         Order2 order = new Order2(new ArrayList<>());
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
     }
 
     @Test
-    void pullAll() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-
-        Order2 order = new Order2(players);
-
-        Player first = order.pull();
-        Player second = order.pull();
-
-        Set<Player> extracted = new HashSet<>();
-        extracted.add(first);
-        extracted.add(second);
-
-        assertEquals(2, extracted.size());
-        assertTrue(extracted.contains(p1));
-        assertTrue(extracted.contains(p2));
-    }
-
-    @Test
-    void pullEmpty() {
+    void wrongIndexHigh() {
         Player p = new Player("p1");
+        Order2 order = new Order2(new ArrayList<>());
 
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-        Order2 order = new Order2(players);
-
-        order.pull();
-
-        assertThrows(NoSuchElementException.class, order::pull);
+        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 2));
     }
 
     @Test
-    void firstPlayer() {
+    void getFirst() {
         Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
+        Order2 order = new Order2(new ArrayList<>());
 
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
+        assertNull(order.getFirst());
 
-        Order2 order = new Order2(players);
+        order.push(p1);
 
-        Player first = order.getFirst();
-
-        assertTrue(first == p1 || first == p2);
+        assertEquals(p1, order.getFirst());
+        assertEquals(p1, order.getFirst());
     }
-
-    @Test
-    void pushZero() {
-        ArrayList<Player> players = new ArrayList<>();
-        Order2 order = new Order2(players);
-
-        Player p = new Player("p1");
-        int initialFood = p.getFoodValue();
-
-        order.push(p);
-
-        assertEquals(initialFood + 1, p.getFoodValue());
-        assertEquals(p, order.getFirst());
-    }
-
-    @Test
-    void pushOneFood() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-
-        Order2 order = new Order2(players);
-
-        p2.addFood(1);
-        int initialPrestige = p2.getPrestigeValue();
-
-        order.push(p2);
-
-        assertEquals(0, p2.getFoodValue());
-        assertEquals(initialPrestige, p2.getPrestigeValue());
-    }
-
-    @Test
-    void pushOneNoFood() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-
-        Order2 order = new Order2(players);
-
-        p2.addPrestige(3);
-
-        order.push(p2);
-
-        assertEquals(1, p2.getPrestigeValue());
-    }
-
-    @Test
-    void pushFull() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-
-        Order2 order = new Order2(players);
-
-        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p3));
-    }
-
 }
\ No newline at end of file

From d0ec86a830a658f894118d0d6ec185963b9eac8c Mon Sep 17 00:00:00 2001
From: MatteoPellegrino05 <matteo1.pellegrino@mail.polimi.it>
Date: Fri, 3 Apr 2026 12:21:16 +0200
Subject: [PATCH 3/3] Fix: OrderTest

---
 .../ingsw/gc14/Model/Orders/Order2Test.java   |   1 -
 .../ingsw/gc14/Model/Orders/Order3Test.java   | 331 +++++-------
 .../ingsw/gc14/Model/Orders/Order4Test.java   | 445 +++++++--------
 .../ingsw/gc14/Model/Orders/Order5Test.java   | 506 +++++++++---------
 4 files changed, 634 insertions(+), 649 deletions(-)

diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
index c703b13..b566c13 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java
@@ -1,6 +1,5 @@
 package it.polimi.ingsw.gc14.Model.Orders;
 
-import it.polimi.ingsw.gc14.Model.Cards.Building.EffectType;
 import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java
index a0ece7e..c15c129 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java
@@ -1,248 +1,209 @@
 package it.polimi.ingsw.gc14.Model.Orders;
 
+import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
-
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.NoSuchElementException;
-import java.util.Set;
-
 import static org.junit.jupiter.api.Assertions.*;
 
 class Order3Test {
 
     @Test
-    void effectZero() {
-        Player p = new Player("Luca");
-        Order3 order = new Order3(new ArrayList<>());
+    void firstReturnGetsFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        Order3 order = new Order3(players);
 
-        int initialFood = p.getFoodValue();
+        Player firstToAct = order.pull();
+        order.pull();
+        order.pull();
 
-        order.effect(p, 0);
+        int initialFood = firstToAct.getFoodValue();
+        order.push(firstToAct);
 
-        assertEquals(initialFood + 2, p.getFoodValue());
+        assertEquals(initialFood + 2, firstToAct.getFoodValue());
+        assertEquals(firstToAct, order.getFirst());
     }
 
     @Test
-    void effectZeroWithBuildingEffect() {
-        Player p = new Player("Luca");
-        Order3 order = new Order3(new ArrayList<>());
+    void secondReturnNoEffect() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        Order3 order = new Order3(players);
 
-        int initialFood = p.getFoodValue();
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        order.pull();
 
-        order.effect(p, 0);
+        int initialFood = secondToAct.getFoodValue();
+        int initialPrestige = secondToAct.getPrestigeValue();
 
-        assertTrue(p.getFoodValue() >= initialFood + 2);
+        order.push(firstToAct);
+        order.push(secondToAct);
+
+        assertEquals(initialFood, secondToAct.getFoodValue());
+        assertEquals(initialPrestige, secondToAct.getPrestigeValue());
     }
 
     @Test
-    void effectOne() {
-        Player p = new Player("Mario");
-        Order3 order = new Order3(new ArrayList<>());
+    void thirdReturnPaysFoodAndLosesPrestige() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        Order3 order = new Order3(players);
 
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
 
-        order.effect(p, 1);
+        thirdToAct.addFood(1);
 
-        assertEquals(initialFood, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+
+        assertEquals(0, thirdToAct.getFoodValue());
+        assertEquals(-2, thirdToAct.getPrestigeValue());
     }
 
     @Test
-    void effectTwoWithFood() {
-        Player p = new Player("Gabriele");
-        Order3 order = new Order3(new ArrayList<>());
+    void thirdReturnWithoutFoodNoEffect() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        Order3 order = new Order3(players);
 
-        p.addFood(1);
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
 
-        order.effect(p, 2);
+        int initialFood = thirdToAct.getFoodValue();
+        int initialPrestige = thirdToAct.getPrestigeValue();
 
-        assertEquals(0, p.getFoodValue());
-        assertEquals(-2, p.getPrestigeValue());
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+
+        assertEquals(initialFood, thirdToAct.getFoodValue());
+        assertEquals(initialPrestige, thirdToAct.getPrestigeValue());
     }
 
     @Test
-    void effectTwoWithoutFood() {
-        Player p = new Player("Giorgio");
-        Order3 order = new Order3(new ArrayList<>());
+    void firstReturnWithBuilding() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        Order3 order = new Order3(players);
 
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
+        Player firstToAct = order.pull();
+        order.pull();
+        order.pull();
 
-        order.effect(p, 2);
+        firstToAct.buildingCards.add(new BuildingCard(3, 1, 1, 2));
 
-        assertEquals(initialFood, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
+        order.push(firstToAct);
+
+        assertEquals(3, firstToAct.getFoodValue());
     }
 
     @Test
-    void effectWrongIndexHigh() {
-        Player p = new Player("Luca");
-        Order3 order = new Order3(new ArrayList<>());
+    void fourthPlayerThrows() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        Order3 order = new Order3(players);
 
-        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 3));
+        order.pull();
+        order.pull();
+        order.pull();
+
+        order.push(p1);
+        order.push(p2);
+        order.push(p3);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p4));
     }
 
     @Test
-    void effectWrongIndexLow() {
-        Player p = new Player("Luca");
+    void constructorLoadsPlayers() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+
+        Order3 order = new Order3(players);
+
+        Player firstOut = order.pull();
+        Player secondOut = order.pull();
+        Player thirdOut = order.pull();
+
+        assertTrue(firstOut == p1 || firstOut == p2 || firstOut == p3);
+        assertTrue(secondOut == p1 || secondOut == p2 || secondOut == p3);
+        assertTrue(thirdOut == p1 || thirdOut == p2 || thirdOut == p3);
+        assertNotEquals(firstOut, secondOut);
+        assertNotEquals(firstOut, thirdOut);
+        assertNotEquals(secondOut, thirdOut);
+        assertThrows(NoSuchElementException.class, order::pull);
+    }
+
+    @Test
+    void wrongIndexLow() {
+        Player p = new Player("p1");
         Order3 order = new Order3(new ArrayList<>());
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
     }
 
     @Test
-    void pullAll() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-
-        Order3 order = new Order3(players);
-
-        Player first = order.pull();
-        Player second = order.pull();
-        Player third = order.pull();
-
-        Set<Player> extracted = new HashSet<>();
-        extracted.add(first);
-        extracted.add(second);
-        extracted.add(third);
-
-        assertEquals(3, extracted.size());
-        assertTrue(extracted.contains(p1));
-        assertTrue(extracted.contains(p2));
-        assertTrue(extracted.contains(p3));
-    }
-
-    @Test
-    void pullEmpty() {
+    void wrongIndexHigh() {
         Player p = new Player("p1");
+        Order3 order = new Order3(new ArrayList<>());
 
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-
-        Order3 order = new Order3(players);
-
-        order.pull();
-
-        assertThrows(NoSuchElementException.class, order::pull);
+        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 3));
     }
 
     @Test
-    void firstPlayer() {
+    void getFirst() {
         Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
+        Order3 order = new Order3(new ArrayList<>());
 
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
+        assertNull(order.getFirst());
 
-        Order3 order = new Order3(players);
+        order.push(p1);
 
-        Player first = order.getFirst();
-
-        assertTrue(first == p1 || first == p2 || first == p3);
+        assertEquals(p1, order.getFirst());
+        assertEquals(p1, order.getFirst());
     }
-
-    @Test
-    void pushZero() {
-        ArrayList<Player> players = new ArrayList<>();
-        Order3 order = new Order3(players);
-
-        Player p = new Player("p1");
-        int initialFood = p.getFoodValue();
-
-        order.push(p);
-
-        assertEquals(initialFood + 2, p.getFoodValue());
-        assertEquals(p, order.getFirst());
-    }
-
-    @Test
-    void pushOne() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-
-        Order3 order = new Order3(players);
-
-        int initialFood = p2.getFoodValue();
-        int initialPrestige = p2.getPrestigeValue();
-
-        order.push(p2);
-
-        assertEquals(initialFood, p2.getFoodValue());
-        assertEquals(initialPrestige, p2.getPrestigeValue());
-    }
-
-    @Test
-    void pushTwoFood() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-
-        Order3 order = new Order3(players);
-
-        p3.addFood(1);
-
-        order.push(p3);
-
-        assertEquals(0, p3.getFoodValue());
-        assertEquals(-2, p3.getPrestigeValue());
-    }
-
-    @Test
-    void pushTwoNoFood() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-
-        Order3 order = new Order3(players);
-
-        int initialFood = p3.getFoodValue();
-        int initialPrestige = p3.getPrestigeValue();
-
-        order.push(p3);
-
-        assertEquals(initialFood, p3.getFoodValue());
-        assertEquals(initialPrestige, p3.getPrestigeValue());
-    }
-
-    @Test
-    void pushFull() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-        Player p4 = new Player("p4");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-
-        Order3 order = new Order3(players);
-
-        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p4));
-    }
-
 }
 
diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java
index 77f23b3..3a683b6 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java
@@ -1,290 +1,291 @@
 package it.polimi.ingsw.gc14.Model.Orders;
 
+import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
-
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.NoSuchElementException;
-import java.util.Set;
-
 import static org.junit.jupiter.api.Assertions.*;
 
 class Order4Test {
 
     @Test
-    void effectZero() {
-        Player p = new Player("Marco");
-        Order4 order = new Order4(new ArrayList<>());
+    void firstReturnGetsFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
 
-        int initialFood = p.getFoodValue();
+        Player firstToAct = order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
 
-        order.effect(p, 0);
+        int initialFood = firstToAct.getFoodValue();
+        order.push(firstToAct);
 
-        assertEquals(initialFood + 2, p.getFoodValue());
+        assertEquals(initialFood + 2, firstToAct.getFoodValue());
+        assertEquals(firstToAct, order.getFirst());
     }
 
     @Test
-    void effectZeroBuild() {
-        Player p = new Player("Luca");
-        Order4 order = new Order4(new ArrayList<>());
+    void secondReturnGetsFood() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
 
-        int initialFood = p.getFoodValue();
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        order.pull();
+        order.pull();
 
-        order.effect(p, 0);
+        int initialFood = secondToAct.getFoodValue();
 
-        assertTrue(p.getFoodValue() >= initialFood + 2);
+        order.push(firstToAct);
+        order.push(secondToAct);
+
+        assertEquals(initialFood + 1, secondToAct.getFoodValue());
     }
 
     @Test
-    void effectOne() {
-        Player p = new Player("Luca");
-        Order4 order = new Order4(new ArrayList<>());
+    void thirdReturnNoEffect() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
 
-        int initialFood = p.getFoodValue();
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
+        order.pull();
 
-        order.effect(p, 1);
+        int initialFood = thirdToAct.getFoodValue();
+        int initialPrestige = thirdToAct.getPrestigeValue();
 
-        assertEquals(initialFood + 1, p.getFoodValue());
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+
+        assertEquals(initialFood, thirdToAct.getFoodValue());
+        assertEquals(initialPrestige, thirdToAct.getPrestigeValue());
     }
 
     @Test
-    void effectTwo() {
-        Player p = new Player("Antonio");
-        Order4 order = new Order4(new ArrayList<>());
+    void fourthReturnPaysFoodAndLosesPrestige() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
 
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
+        Player fourthToAct = order.pull();
 
-        order.effect(p, 2);
+        fourthToAct.addFood(1);
 
-        assertEquals(initialFood, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+        order.push(fourthToAct);
+
+        assertEquals(0, fourthToAct.getFoodValue());
+        assertEquals(-2, fourthToAct.getPrestigeValue());
     }
 
     @Test
-    void effectThreeWithFood() {
-        Player p = new Player("Giovanni");
-        Order4 order = new Order4(new ArrayList<>());
+    void fourthReturnWithoutFoodNoEffect() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
 
-        p.addFood(1);
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
+        Player fourthToAct = order.pull();
 
-        order.effect(p, 3);
+        int initialFood = fourthToAct.getFoodValue();
+        int initialPrestige = fourthToAct.getPrestigeValue();
 
-        assertEquals(0, p.getFoodValue());
-        assertEquals(-2, p.getPrestigeValue());
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+        order.push(fourthToAct);
+
+        assertEquals(initialFood, fourthToAct.getFoodValue());
+        assertEquals(initialPrestige, fourthToAct.getPrestigeValue());
     }
 
     @Test
-    void effectThreeWithoutFood() {
-        Player p = new Player("test");
-        Order4 order = new Order4(new ArrayList<>());
+    void firstReturnWithBuilding() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
 
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
+        Player firstToAct = order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
 
-        order.effect(p, 3);
+        firstToAct.buildingCards.add(new BuildingCard(3, 1, 1, 2));
 
-        assertEquals(initialFood, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
+        order.push(firstToAct);
+
+        assertEquals(3, firstToAct.getFoodValue());
     }
 
     @Test
-    void effectWrongIndexHigh() {
-        Player p = new Player("Marco");
-        Order4 order = new Order4(new ArrayList<>());
+    void secondReturnWithBuilding() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
 
-        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 4));
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        order.pull();
+        order.pull();
+
+        secondToAct.buildingCards.add(new BuildingCard(3, 1, 1, 2));
+
+        order.push(firstToAct);
+        order.push(secondToAct);
+
+        assertEquals(2, secondToAct.getFoodValue());
     }
 
     @Test
-    void effectWrongIndexLow() {
-        Player p = new Player("Marco");
+    void fifthPlayerThrows() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        Order4 order = new Order4(players);
+
+        order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
+
+        order.push(p1);
+        order.push(p2);
+        order.push(p3);
+        order.push(p4);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p5));
+    }
+
+    @Test
+    void constructorLoadsPlayers() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+
+        Order4 order = new Order4(players);
+
+        Player firstOut = order.pull();
+        Player secondOut = order.pull();
+        Player thirdOut = order.pull();
+        Player fourthOut = order.pull();
+
+        assertTrue(firstOut == p1 || firstOut == p2 || firstOut == p3 || firstOut == p4);
+        assertTrue(secondOut == p1 || secondOut == p2 || secondOut == p3 || secondOut == p4);
+        assertTrue(thirdOut == p1 || thirdOut == p2 || thirdOut == p3 || thirdOut == p4);
+        assertTrue(fourthOut == p1 || fourthOut == p2 || fourthOut == p3 || fourthOut == p4);
+
+        assertNotEquals(firstOut, secondOut);
+        assertNotEquals(firstOut, thirdOut);
+        assertNotEquals(firstOut, fourthOut);
+        assertNotEquals(secondOut, thirdOut);
+        assertNotEquals(secondOut, fourthOut);
+        assertNotEquals(thirdOut, fourthOut);
+
+        assertThrows(NoSuchElementException.class, order::pull);
+    }
+
+    @Test
+    void wrongIndexLow() {
+        Player p = new Player("p1");
         Order4 order = new Order4(new ArrayList<>());
 
         assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
     }
 
     @Test
-    void pullAll() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-        Player p4 = new Player("p4");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-        players.add(p4);
-
-        Order4 order = new Order4(players);
-
-        Player first = order.pull();
-        Player second = order.pull();
-        Player third = order.pull();
-        Player fourth = order.pull();
-
-        Set<Player> extracted = new HashSet<>();
-        extracted.add(first);
-        extracted.add(second);
-        extracted.add(third);
-        extracted.add(fourth);
-
-        assertEquals(4, extracted.size());
-        assertTrue(extracted.contains(p1));
-        assertTrue(extracted.contains(p2));
-        assertTrue(extracted.contains(p3));
-        assertTrue(extracted.contains(p4));
-    }
-
-    @Test
-    void pullEmpty() {
+    void wrongIndexHigh() {
         Player p = new Player("p1");
+        Order4 order = new Order4(new ArrayList<>());
 
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-
-        Order4 order = new Order4(players);
-
-        order.pull();
-
-        assertThrows(NoSuchElementException.class, order::pull);
+        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 4));
     }
 
     @Test
-    void firstPlayer() {
+    void getFirst() {
         Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-        Player p4 = new Player("p4");
+        Order4 order = new Order4(new ArrayList<>());
 
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-        players.add(p4);
+        assertNull(order.getFirst());
 
-        Order4 order = new Order4(players);
+        order.push(p1);
 
-        Player first = order.getFirst();
-
-        assertTrue(first == p1 || first == p2 || first == p3 || first == p4);
-    }
-
-    @Test
-    void pushZero() {
-        ArrayList<Player> players = new ArrayList<>();
-        Order4 order = new Order4(players);
-
-        Player p = new Player("p1");
-        int initialFood = p.getFoodValue();
-
-        order.push(p);
-
-        assertEquals(initialFood + 2, p.getFoodValue());
-        assertEquals(p, order.getFirst());
-    }
-
-    @Test
-    void pushOne() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-
-        Order4 order = new Order4(players);
-
-        int initialFood = p2.getFoodValue();
-
-        order.push(p2);
-
-        assertEquals(initialFood + 1, p2.getFoodValue());
-    }
-
-    @Test
-    void pushTwo() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-
-        Order4 order = new Order4(players);
-
-        int initialFood = p3.getFoodValue();
-        int initialPrestige = p3.getPrestigeValue();
-
-        order.push(p3);
-
-        assertEquals(initialFood, p3.getFoodValue());
-        assertEquals(initialPrestige, p3.getPrestigeValue());
-    }
-
-    @Test
-    void pushThreeFood() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-        Player p4 = new Player("p4");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-
-        Order4 order = new Order4(players);
-
-        p4.addFood(1);
-
-        order.push(p4);
-
-        assertEquals(0, p4.getFoodValue());
-        assertEquals(-2, p4.getPrestigeValue());
-    }
-
-    @Test
-    void pushThreeNoFood() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-        Player p4 = new Player("p4");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-
-        Order4 order = new Order4(players);
-
-        int initialFood = p4.getFoodValue();
-        int initialPrestige = p4.getPrestigeValue();
-
-        order.push(p4);
-
-        assertEquals(initialFood, p4.getFoodValue());
-        assertEquals(initialPrestige, p4.getPrestigeValue());
-    }
-
-    @Test
-    void pushFull() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-        Player p4 = new Player("p4");
-        Player p5 = new Player("p5");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-        players.add(p4);
-
-        Order4 order = new Order4(players);
-
-        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p5));
+        assertEquals(p1, order.getFirst());
+        assertEquals(p1, order.getFirst());
     }
 }
\ No newline at end of file
diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java
index 01fbf4f..a9a21c7 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java
@@ -1,5 +1,6 @@
 package it.polimi.ingsw.gc14.Model.Orders;
 
+import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.Test;
 
@@ -10,325 +11,297 @@ import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.*;
 
+import org.junit.jupiter.api.Test;
+import java.util.ArrayList;
+import java.util.NoSuchElementException;
+import static org.junit.jupiter.api.Assertions.*;
+
 class Order5Test {
 
     @Test
-    void effectZero() {
-        Player p = new Player("Marco");
-        Order5 order = new Order5(new ArrayList<>());
-
-        int initialFood = p.getFoodValue();
-
-        order.effect(p, 0);
-
-        assertEquals(initialFood + 3, p.getFoodValue());
-        assertEquals(0, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectZeroBuild() {
-        Player p = new Player("Luca");
-        Order5 order = new Order5(new ArrayList<>());
-
-        int initialFood = p.getFoodValue();
-
-        order.effect(p, 0);
-
-        assertTrue(p.getFoodValue() >= initialFood + 3);
-    }
-
-    @Test
-    void effectOne() {
-        Player p = new Player("Luca");
-        Order5 order = new Order5(new ArrayList<>());
-
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
-
-        order.effect(p, 1);
-
-        assertEquals(initialFood + 1, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectTwo() {
-        Player p = new Player("Antonio");
-        Order5 order = new Order5(new ArrayList<>());
-
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
-
-        order.effect(p, 2);
-
-        assertEquals(initialFood, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectThree() {
-        Player p = new Player("Giovanni");
-        Order5 order = new Order5(new ArrayList<>());
-
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
-
-        order.effect(p, 3);
-
-        assertEquals(initialFood, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectFourWithFood() {
-        Player p = new Player("Francesco");
-        Order5 order = new Order5(new ArrayList<>());
-
-        p.addFood(1);
-
-        order.effect(p, 4);
-
-        assertEquals(0, p.getFoodValue());
-        assertEquals(-2, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectFourWithoutFood() {
-        Player p = new Player("Giulio");
-        Order5 order = new Order5(new ArrayList<>());
-
-        int initialFood = p.getFoodValue();
-        int initialPrestige = p.getPrestigeValue();
-
-        order.effect(p, 4);
-
-        assertEquals(initialFood, p.getFoodValue());
-        assertEquals(initialPrestige, p.getPrestigeValue());
-    }
-
-    @Test
-    void effectWrongIndexHigh() {
-        Player p = new Player("Marco");
-        Order5 order = new Order5(new ArrayList<>());
-
-        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 5));
-    }
-
-    @Test
-    void effectWrongIndexLow() {
-        Player p = new Player("Marco");
-        Order5 order = new Order5(new ArrayList<>());
-
-        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
-    }
-
-    @Test
-    void pullAll() {
+    void firstReturnGetsFood() {
         Player p1 = new Player("p1");
         Player p2 = new Player("p2");
         Player p3 = new Player("p3");
         Player p4 = new Player("p4");
         Player p5 = new Player("p5");
-
         ArrayList<Player> players = new ArrayList<>();
         players.add(p1);
         players.add(p2);
         players.add(p3);
         players.add(p4);
         players.add(p5);
-
-        Order5 order = new Order5(players);
-
-        Player first = order.pull();
-        Player second = order.pull();
-        Player third = order.pull();
-        Player fourth = order.pull();
-        Player fifth = order.pull();
-
-        Set<Player> extracted = new HashSet<>();
-        extracted.add(first);
-        extracted.add(second);
-        extracted.add(third);
-        extracted.add(fourth);
-        extracted.add(fifth);
-
-        assertEquals(5, extracted.size());
-        assertTrue(extracted.contains(p1));
-        assertTrue(extracted.contains(p2));
-        assertTrue(extracted.contains(p3));
-        assertTrue(extracted.contains(p4));
-        assertTrue(extracted.contains(p5));
-    }
-
-    @Test
-    void pullEmpty() {
-        Player p = new Player("p1");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p);
-
         Order5 order = new Order5(players);
 
+        Player firstToAct = order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
         order.pull();
 
-        assertThrows(NoSuchElementException.class, order::pull);
+        int initialFood = firstToAct.getFoodValue();
+        order.push(firstToAct);
+
+        assertEquals(initialFood + 3, firstToAct.getFoodValue());
+        assertEquals(firstToAct, order.getFirst());
     }
 
     @Test
-    void firstPlayer() {
+    void secondReturnGetsFood() {
         Player p1 = new Player("p1");
         Player p2 = new Player("p2");
         Player p3 = new Player("p3");
         Player p4 = new Player("p4");
         Player p5 = new Player("p5");
-
         ArrayList<Player> players = new ArrayList<>();
         players.add(p1);
         players.add(p2);
         players.add(p3);
         players.add(p4);
         players.add(p5);
-
         Order5 order = new Order5(players);
 
-        Player first = order.getFirst();
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
 
-        assertTrue(first == p1 || first == p2 || first == p3 || first == p4 || first == p5);
+        int initialFood = secondToAct.getFoodValue();
+
+        order.push(firstToAct);
+        order.push(secondToAct);
+
+        assertEquals(initialFood + 1, secondToAct.getFoodValue());
     }
 
     @Test
-    void pushZero() {
-        ArrayList<Player> players = new ArrayList<>();
-        Order5 order = new Order5(players);
-
-        Player p = new Player("p1");
-        int initialFood = p.getFoodValue();
-
-        order.push(p);
-
-        assertEquals(initialFood + 3, p.getFoodValue());
-        assertEquals(p, order.getFirst());
-    }
-
-    @Test
-    void pushOne() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-
-        Order5 order = new Order5(players);
-
-        int initialFood = p2.getFoodValue();
-
-        order.push(p2);
-
-        assertEquals(initialFood + 1, p2.getFoodValue());
-    }
-
-    @Test
-    void pushTwo() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-
-        Order5 order = new Order5(players);
-
-        int initialFood = p3.getFoodValue();
-        int initialPrestige = p3.getPrestigeValue();
-
-        order.push(p3);
-
-        assertEquals(initialFood, p3.getFoodValue());
-        assertEquals(initialPrestige, p3.getPrestigeValue());
-    }
-
-    @Test
-    void pushThree() {
-        Player p1 = new Player("p1");
-        Player p2 = new Player("p2");
-        Player p3 = new Player("p3");
-        Player p4 = new Player("p4");
-
-        ArrayList<Player> players = new ArrayList<>();
-        players.add(p1);
-        players.add(p2);
-        players.add(p3);
-
-        Order5 order = new Order5(players);
-
-        int initialFood = p4.getFoodValue();
-        int initialPrestige = p4.getPrestigeValue();
-
-        order.push(p4);
-
-        assertEquals(initialFood, p4.getFoodValue());
-        assertEquals(initialPrestige, p4.getPrestigeValue());
-    }
-
-    @Test
-    void pushFourFood() {
+    void thirdReturnNoEffect() {
         Player p1 = new Player("p1");
         Player p2 = new Player("p2");
         Player p3 = new Player("p3");
         Player p4 = new Player("p4");
         Player p5 = new Player("p5");
-
         ArrayList<Player> players = new ArrayList<>();
         players.add(p1);
         players.add(p2);
         players.add(p3);
         players.add(p4);
-
+        players.add(p5);
         Order5 order = new Order5(players);
 
-        p5.addFood(1);
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
+        order.pull();
+        order.pull();
 
-        order.push(p5);
+        int initialFood = thirdToAct.getFoodValue();
+        int initialPrestige = thirdToAct.getPrestigeValue();
 
-        assertEquals(0, p5.getFoodValue());
-        assertEquals(-2, p5.getPrestigeValue());
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+
+        assertEquals(initialFood, thirdToAct.getFoodValue());
+        assertEquals(initialPrestige, thirdToAct.getPrestigeValue());
     }
 
     @Test
-    void pushFourNoFood() {
+    void fourthReturnNoEffect() {
         Player p1 = new Player("p1");
         Player p2 = new Player("p2");
         Player p3 = new Player("p3");
         Player p4 = new Player("p4");
         Player p5 = new Player("p5");
-
         ArrayList<Player> players = new ArrayList<>();
         players.add(p1);
         players.add(p2);
         players.add(p3);
         players.add(p4);
-
+        players.add(p5);
         Order5 order = new Order5(players);
 
-        int initialFood = p5.getFoodValue();
-        int initialPrestige = p5.getPrestigeValue();
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
+        Player fourthToAct = order.pull();
+        order.pull();
 
-        order.push(p5);
+        int initialFood = fourthToAct.getFoodValue();
+        int initialPrestige = fourthToAct.getPrestigeValue();
 
-        assertEquals(initialFood, p5.getFoodValue());
-        assertEquals(initialPrestige, p5.getPrestigeValue());
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+        order.push(fourthToAct);
+
+        assertEquals(initialFood, fourthToAct.getFoodValue());
+        assertEquals(initialPrestige, fourthToAct.getPrestigeValue());
     }
 
     @Test
-    void pushFull() {
+    void fifthReturnPaysFoodAndLosesPrestige() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+        Order5 order = new Order5(players);
+
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
+        Player fourthToAct = order.pull();
+        Player fifthToAct = order.pull();
+
+        fifthToAct.addFood(1);
+
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+        order.push(fourthToAct);
+        order.push(fifthToAct);
+
+        assertEquals(0, fifthToAct.getFoodValue());
+        assertEquals(-2, fifthToAct.getPrestigeValue());
+    }
+
+    @Test
+    void fifthReturnWithoutFoodNoEffect() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+        Order5 order = new Order5(players);
+
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        Player thirdToAct = order.pull();
+        Player fourthToAct = order.pull();
+        Player fifthToAct = order.pull();
+
+        int initialFood = fifthToAct.getFoodValue();
+        int initialPrestige = fifthToAct.getPrestigeValue();
+
+        order.push(firstToAct);
+        order.push(secondToAct);
+        order.push(thirdToAct);
+        order.push(fourthToAct);
+        order.push(fifthToAct);
+
+        assertEquals(initialFood, fifthToAct.getFoodValue());
+        assertEquals(initialPrestige, fifthToAct.getPrestigeValue());
+    }
+
+    @Test
+    void firstReturnWithBuilding() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+        Order5 order = new Order5(players);
+
+        Player firstToAct = order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
+
+        firstToAct.buildingCards.add(new BuildingCard(3, 1, 1, 2));
+
+        order.push(firstToAct);
+
+        assertEquals(4, firstToAct.getFoodValue());
+    }
+
+    @Test
+    void secondReturnWithBuilding() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+        Order5 order = new Order5(players);
+
+        Player firstToAct = order.pull();
+        Player secondToAct = order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
+
+        secondToAct.buildingCards.add(new BuildingCard(3, 1, 1, 2));
+
+        order.push(firstToAct);
+        order.push(secondToAct);
+
+        assertEquals(2, secondToAct.getFoodValue());
+    }
+
+    @Test
+    void sixthPlayerThrows() {
         Player p1 = new Player("p1");
         Player p2 = new Player("p2");
         Player p3 = new Player("p3");
         Player p4 = new Player("p4");
         Player p5 = new Player("p5");
         Player p6 = new Player("p6");
+        ArrayList<Player> players = new ArrayList<>();
+        players.add(p1);
+        players.add(p2);
+        players.add(p3);
+        players.add(p4);
+        players.add(p5);
+        Order5 order = new Order5(players);
 
+        order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
+        order.pull();
+
+        order.push(p1);
+        order.push(p2);
+        order.push(p3);
+        order.push(p4);
+        order.push(p5);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p6));
+    }
+
+    @Test
+    void constructorLoadsPlayers() {
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
         ArrayList<Player> players = new ArrayList<>();
         players.add(p1);
         players.add(p2);
@@ -338,9 +311,60 @@ class Order5Test {
 
         Order5 order = new Order5(players);
 
-        assertThrows(IndexOutOfBoundsException.class, () -> order.push(p6));
+        Player firstOut = order.pull();
+        Player secondOut = order.pull();
+        Player thirdOut = order.pull();
+        Player fourthOut = order.pull();
+        Player fifthOut = order.pull();
+
+        assertTrue(firstOut == p1 || firstOut == p2 || firstOut == p3 || firstOut == p4 || firstOut == p5);
+        assertTrue(secondOut == p1 || secondOut == p2 || secondOut == p3 || secondOut == p4 || secondOut == p5);
+        assertTrue(thirdOut == p1 || thirdOut == p2 || thirdOut == p3 || thirdOut == p4 || thirdOut == p5);
+        assertTrue(fourthOut == p1 || fourthOut == p2 || fourthOut == p3 || fourthOut == p4 || fourthOut == p5);
+        assertTrue(fifthOut == p1 || fifthOut == p2 || fifthOut == p3 || fifthOut == p4 || fifthOut == p5);
+
+        assertNotEquals(firstOut, secondOut);
+        assertNotEquals(firstOut, thirdOut);
+        assertNotEquals(firstOut, fourthOut);
+        assertNotEquals(firstOut, fifthOut);
+        assertNotEquals(secondOut, thirdOut);
+        assertNotEquals(secondOut, fourthOut);
+        assertNotEquals(secondOut, fifthOut);
+        assertNotEquals(thirdOut, fourthOut);
+        assertNotEquals(thirdOut, fifthOut);
+        assertNotEquals(fourthOut, fifthOut);
+
+        assertThrows(NoSuchElementException.class, order::pull);
     }
 
+    @Test
+    void wrongIndexLow() {
+        Player p = new Player("p1");
+        Order5 order = new Order5(new ArrayList<>());
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, -1));
+    }
+
+    @Test
+    void wrongIndexHigh() {
+        Player p = new Player("p1");
+        Order5 order = new Order5(new ArrayList<>());
+
+        assertThrows(IndexOutOfBoundsException.class, () -> order.effect(p, 5));
+    }
+
+    @Test
+    void getFirst() {
+        Player p1 = new Player("p1");
+        Order5 order = new Order5(new ArrayList<>());
+
+        assertNull(order.getFirst());
+
+        order.push(p1);
+
+        assertEquals(p1, order.getFirst());
+        assertEquals(p1, order.getFirst());
+    }
 }