Fix: OrderTests

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));
+    }
+
 }

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));
     }
-}
+
+    @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));
+    }
+
+}
+

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));
+    }
 }

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));
     }
-}
+
+    @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));
+    }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+