Add: complete Character card tests for constructors, cloning and insertion logic

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/ArtistTest.java

@@ -19,20 +19,21 @@ class ArtistTest {
 
     @Test
     void testClone() {
-        Artist a = new Artist(1, 3);
+        Artist a = new Artist("artist1", 1, 3);
         Artist clone = (Artist) a.clone();
 
         assertNotNull(clone);
+        assertNotSame(a, clone);
+        assertEquals(a.getIdIMG(), clone.getIdIMG());
         assertEquals(a.getEra(), clone.getEra());
         assertEquals(a.getNMin(), clone.getNMin());
-        assertNotSame(a, clone);
         assertEquals(a.getType(), clone.getType());
     }
 
     @Test
-    void insert() {
+    void insertTest() {
         Player p = new Player("test");
-        Artist a = new Artist(1);
+        Artist a = new Artist(1, 5);
 
         assertEquals(0, p.artists.size());
 
@@ -41,11 +42,11 @@ class ArtistTest {
         assertEquals(1, p.artists.size());
         assertTrue(p.artists.contains(a));
 
-        Artist a2 = new Artist(1);
+        Artist insertedArtist = p.artists.get(0);
-        a2.insert(p);
+        assertSame(a, insertedArtist);
-
+        assertEquals(1, insertedArtist.getEra());
-        assertEquals(2, p.artists.size());
+        assertEquals(5, insertedArtist.getNMin());
-        assertTrue(p.artists.contains(a2));
+        assertEquals(CharacterType.ARTIST, insertedArtist.getType());
     }
 
     @Test
@@ -68,5 +69,25 @@ class ArtistTest {
         assertFalse(a.IsEventCard());
     }
 
+    @Test
+    void constructorWithIdIMGTest() {
+        Artist a = new Artist("artist1", 1);
 
+        assertEquals("artist1", a.getIdIMG());
+        assertEquals(1, a.getEra());
+        assertEquals(CharacterType.ARTIST, a.getType());
+        assertEquals(0, a.getNMin());
+        assertFalse(a.IsEventCard());
+    }
+
+    @Test
+    void constructorWithIdIMGAndNMinTest() {
+        Artist a = new Artist("artist1", 1, 3);
+
+        assertEquals("artist1", a.getIdIMG());
+        assertEquals(1, a.getEra());
+        assertEquals(CharacterType.ARTIST, a.getType());
+        assertEquals(3, a.getNMin());
+        assertFalse(a.IsEventCard());
+    }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/BuilderTest.java

@@ -10,34 +10,36 @@ class BuilderTest {
 
     @Test
     void getReductionValue() {
-        Builder b = new Builder(1, 2 , 3);
+        Builder b = new Builder(1, 2, 3);
 
         assertEquals(2, b.getReductionValue());
     }
 
     @Test
     void getPrestigeValue() {
-        Builder b = new Builder(1, 2 , 3);
+        Builder b = new Builder(1, 2, 3);
+
         assertEquals(3, b.getPrestigeValue());
     }
 
     @Test
     void testToString() {
-        Builder b = new Builder(1, 2 , 3);
+        Builder b = new Builder(1, 2, 3);
         String s = b.toString();
 
         assertNotNull(s);
         assertFalse(s.contains(CharacterType.BUILDER.toString()));
-        assertEquals("⎕:" + " RV:" + b.getReductionValue() + " PV:" +  b.getPrestigeValue(), s);
+        assertEquals("⎕:" + " RV:" + b.getReductionValue() + " PV:" + b.getPrestigeValue(), s);
     }
 
     @Test
     void testClone() {
-        Builder b = new Builder(1, 2, 3, 4);
+        Builder b = new Builder("builder1", 1, 2, 3, 4);
         Builder clone = (Builder) b.clone();
 
         assertNotNull(clone);
         assertNotSame(b, clone);
+        assertEquals(b.getIdIMG(), clone.getIdIMG());
         assertEquals(b.getEra(), clone.getEra());
         assertEquals(b.getType(), clone.getType());
         assertEquals(b.getReductionValue(), clone.getReductionValue());
@@ -46,9 +48,9 @@ class BuilderTest {
     }
 
     @Test
-    void insert() {
+    void insertTest() {
         Player p = new Player("test");
-        Builder b = new Builder(1, 2, 3);
+        Builder b = new Builder(1, 2, 3, 5);
 
         assertEquals(0, p.builders.size());
 
@@ -57,11 +59,13 @@ class BuilderTest {
         assertEquals(1, p.builders.size());
         assertTrue(p.builders.contains(b));
 
-        Builder b2 = new Builder(1, 4, 5);
+        Builder insertedBuilder = p.builders.get(0);
-        b2.insert(p);
+        assertSame(b, insertedBuilder);
-
+        assertEquals(1, insertedBuilder.getEra());
-        assertEquals(2, p.builders.size());
+        assertEquals(5, insertedBuilder.getNMin());
-        assertTrue(p.builders.contains(b2));
+        assertEquals(CharacterType.BUILDER, insertedBuilder.getType());
+        assertEquals(2, insertedBuilder.getReductionValue());
+        assertEquals(3, insertedBuilder.getPrestigeValue());
     }
 
     @Test
@@ -78,7 +82,6 @@ class BuilderTest {
 
     @Test
     void constructorWithNMinTest() {
-        // Correct case
         Builder b = new Builder(1, 2, 3, 4);
 
         assertEquals(1, b.getEra());
@@ -88,41 +91,47 @@ class BuilderTest {
         assertEquals(4, b.getNMin());
         assertFalse(b.IsEventCard());
 
-        // Wrong reductionValue
+        assertThrows(IllegalArgumentException.class, () ->
-        assertThrows(IllegalArgumentException.class, () -> {new Builder(1, -1, 3, 4);});
+                new Builder(1, -1, 3, 4)
+        );
 
-        // Wrong prestigeValue
+        assertThrows(IllegalArgumentException.class, () ->
-        assertThrows(IllegalArgumentException.class, () -> {new Builder(1, 2, -1, 4);});
+                new Builder(1, 2, -1, 4)
+        );
     }
 
     @Test
     void negativeReductionValue() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        assertThrows(IllegalArgumentException.class, () ->
-            new Builder(1, -1, 3);
+                new Builder(1, -1, 3)
-        });
+        );
     }
 
     @Test
     void negativePrestigeValue() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        assertThrows(IllegalArgumentException.class, () ->
-            new Builder(1, 2, -3);
+                new Builder(1, 2, -3)
-        });
+        );
     }
 
     @Test
     void constructorWithIdIMGTest() {
         Builder b = new Builder("builder1", 1, 2, 3);
 
+        assertEquals("builder1", b.getIdIMG());
         assertEquals(1, b.getEra());
         assertEquals(CharacterType.BUILDER, b.getType());
         assertEquals(2, b.getReductionValue());
         assertEquals(3, b.getPrestigeValue());
+        assertEquals(0, b.getNMin());
+        assertFalse(b.IsEventCard());
     }
 
     @Test
     void constructorWithIdIMGAndNMinTest() {
         Builder b = new Builder("builder1", 1, 2, 3, 4);
 
+        assertEquals("builder1", b.getIdIMG());
         assertEquals(1, b.getEra());
         assertEquals(CharacterType.BUILDER, b.getType());
         assertEquals(2, b.getReductionValue());
@@ -153,7 +162,6 @@ class BuilderTest {
     @Test
     void testToStringBoard() {
         Builder b = new Builder(1, 2, 3);
-
         String s = b.toStringBoard();
 
         assertNotNull(s);

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/GathererTest.java

@@ -20,20 +20,21 @@ class GathererTest {
 
     @Test
     void testClone() {
-        Gatherer g = new Gatherer(1, 3);
+        Gatherer g = new Gatherer("gatherer1", 1, 3);
         Gatherer clone = (Gatherer) g.clone();
 
         assertNotNull(clone);
+        assertNotSame(g, clone);
+        assertEquals(g.getIdIMG(), clone.getIdIMG());
         assertEquals(g.getEra(), clone.getEra());
         assertEquals(g.getNMin(), clone.getNMin());
-        assertNotSame(g, clone);
         assertEquals(g.getType(), clone.getType());
     }
 
     @Test
-    void insert() {
+    void insertTest() {
         Player p = new Player("test");
-        Gatherer g = new Gatherer(1);
+        Gatherer g = new Gatherer(1, 5);
 
         assertEquals(0, p.gatherers.size());
 
@@ -42,11 +43,11 @@ class GathererTest {
         assertEquals(1, p.gatherers.size());
         assertTrue(p.gatherers.contains(g));
 
-        Gatherer g2 = new Gatherer(1);
+        Gatherer insertedGatherer = p.gatherers.get(0);
-        g2.insert(p);
+        assertSame(g, insertedGatherer);
-
+        assertEquals(1, insertedGatherer.getEra());
-        assertEquals(2, p.gatherers.size());
+        assertEquals(5, insertedGatherer.getNMin());
-        assertTrue(p.gatherers.contains(g2));
+        assertEquals(CharacterType.GATHERER, insertedGatherer.getType());
     }
 
     @Test
@@ -68,4 +69,26 @@ class GathererTest {
         assertEquals(3, g.getNMin());
         assertFalse(g.IsEventCard());
     }
+
+    @Test
+    void constructorWithIdIMGTest() {
+        Gatherer g = new Gatherer("gatherer1", 1);
+
+        assertEquals("gatherer1", g.getIdIMG());
+        assertEquals(1, g.getEra());
+        assertEquals(CharacterType.GATHERER, g.getType());
+        assertEquals(0, g.getNMin());
+        assertFalse(g.IsEventCard());
+    }
+
+    @Test
+    void constructorWithIdIMGAndNMinTest() {
+        Gatherer g = new Gatherer("gatherer1", 1, 3);
+
+        assertEquals("gatherer1", g.getIdIMG());
+        assertEquals(1, g.getEra());
+        assertEquals(CharacterType.GATHERER, g.getType());
+        assertEquals(3, g.getNMin());
+        assertFalse(g.IsEventCard());
+    }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/HunterTest.java

@@ -35,11 +35,12 @@ class HunterTest {
 
     @Test
     void testClone() {
-        Hunter h = new Hunter(1, true, 3);
+        Hunter h = new Hunter("hunter1", 1, true, 3);
         Hunter clone = (Hunter) h.clone();
 
         assertNotNull(clone);
         assertNotSame(h, clone);
+        assertEquals(h.getIdIMG(), clone.getIdIMG());
         assertEquals(h.getEra(), clone.getEra());
         assertEquals(h.getType(), clone.getType());
         assertEquals(h.getIcon(), clone.getIcon());
@@ -47,36 +48,62 @@ class HunterTest {
     }
 
     @Test
-    void insert() {
+    void insertTest() {
         Player p = new Player("test");
-        Hunter h = new Hunter(1, true);
+        Hunter h = new Hunter(1, true, 5);
 
         assertEquals(0, p.hunters.size());
+        assertEquals(0, p.getFoodValue());
 
         h.insert(p);
 
         assertEquals(1, p.hunters.size());
         assertTrue(p.hunters.contains(h));
 
+        Hunter insertedHunter = p.hunters.get(0);
+        assertSame(h, insertedHunter);
+        assertEquals(1, insertedHunter.getEra());
+        assertEquals(5, insertedHunter.getNMin());
+        assertEquals(CharacterType.HUNTER, insertedHunter.getType());
+        assertTrue(insertedHunter.getIcon());
+
+        // Since this Hunter has the icon and is the first Hunter inserted,
+        // the player receives 1 food token.
+        assertEquals(1, p.getFoodValue());
+    }
+
+    @Test
+    void insertWithoutIconDoesNotAddFoodTest() {
+        Player p = new Player("test");
+        Hunter h = new Hunter(1, false);
+
+        assertEquals(0, p.getFoodValue());
+
+        h.insert(p);
+
+        assertEquals(1, p.hunters.size());
+        assertTrue(p.hunters.contains(h));
+        assertEquals(0, p.getFoodValue());
+    }
+
+    @Test
+    void insertWithIconAddsFoodForEachHunterInTribeTest() {
+        Player p = new Player("test");
+
+        Hunter h1 = new Hunter(1, true);
         Hunter h2 = new Hunter(1, false);
-        h2.insert(p);
-
-        assertEquals(2, p.hunters.size());
-        assertTrue(p.hunters.contains(h2));
-
-        Player p2 = new Player("test2");
         Hunter h3 = new Hunter(1, true);
 
-        assertEquals(0, p2.getFoodValue());
+        assertEquals(0, p.getFoodValue());
-        h.insert(p2);
 
-        assertEquals(1, p2.getFoodValue());
+        h1.insert(p);
-        h2.insert(p2);
+        assertEquals(1, p.getFoodValue());
 
-        assertEquals(1, p2.getFoodValue());
+        h2.insert(p);
-        h3.insert(p2);
+        assertEquals(1, p.getFoodValue());
 
-        assertEquals(4, p2.getFoodValue());
+        h3.insert(p);
+        assertEquals(4, p.getFoodValue());
     }
 
     @Test
@@ -100,4 +127,28 @@ class HunterTest {
         assertEquals(3, h.getNMin());
         assertFalse(h.IsEventCard());
     }
+
+    @Test
+    void constructorWithIdIMGTest() {
+        Hunter h = new Hunter("hunter1", 1, true);
+
+        assertEquals("hunter1", h.getIdIMG());
+        assertEquals(1, h.getEra());
+        assertEquals(CharacterType.HUNTER, h.getType());
+        assertTrue(h.getIcon());
+        assertEquals(0, h.getNMin());
+        assertFalse(h.IsEventCard());
+    }
+
+    @Test
+    void constructorWithIdIMGAndNMinTest() {
+        Hunter h = new Hunter("hunter1", 1, false, 3);
+
+        assertEquals("hunter1", h.getIdIMG());
+        assertEquals(1, h.getEra());
+        assertEquals(CharacterType.HUNTER, h.getType());
+        assertFalse(h.getIcon());
+        assertEquals(3, h.getNMin());
+        assertFalse(h.IsEventCard());
+    }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/InventorTest.java

@@ -22,16 +22,26 @@ class InventorTest {
 
         assertNotNull(s);
         assertFalse(s.contains(CharacterType.INVENTOR.toString()));
-        assertEquals("⎕:" + " I_ID:" + i.Icon(), i.toString());
+        assertEquals("⎕:" + " I_ID:" + i.Icon(), s);
+    }
+
+    @Test
+    void testToStringBoard() {
+        Inventor i = new Inventor(1, 5);
+        String s = i.toStringBoard();
+
+        assertNotNull(s);
+        assertTrue(s.contains("I_ID:5"));
     }
 
     @Test
     void testClone() {
-        Inventor i = new Inventor(1, 5, 3);
+        Inventor i = new Inventor("inventor1", 1, 5, 3);
         Inventor clone = (Inventor) i.clone();
 
         assertNotNull(clone);
         assertNotSame(i, clone);
+        assertEquals(i.getIdIMG(), clone.getIdIMG());
         assertEquals(i.getEra(), clone.getEra());
         assertEquals(i.getType(), clone.getType());
         assertEquals(i.Icon(), clone.Icon());
@@ -39,9 +49,9 @@ class InventorTest {
     }
 
     @Test
-    void insert() {
+    void insertTest() {
         Player p = new Player("test");
-        Inventor i = new Inventor(1, 5);
+        Inventor i = new Inventor(1, 5, 5);
 
         assertEquals(0, p.inventors.size());
 
@@ -50,11 +60,12 @@ class InventorTest {
         assertEquals(1, p.inventors.size());
         assertTrue(p.inventors.contains(i));
 
-        Inventor i2 = new Inventor(1, 7);
+        Inventor insertedInventor = p.inventors.get(0);
-        i2.insert(p);
+        assertSame(i, insertedInventor);
-
+        assertEquals(1, insertedInventor.getEra());
-        assertEquals(2, p.inventors.size());
+        assertEquals(5, insertedInventor.getNMin());
-        assertTrue(p.inventors.contains(i2));
+        assertEquals(CharacterType.INVENTOR, insertedInventor.getType());
+        assertEquals(5, insertedInventor.Icon());
     }
 
     @Test
@@ -79,38 +90,11 @@ class InventorTest {
         assertFalse(i.IsEventCard());
     }
 
-    @Test
-    void negativeIcon() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new Inventor(1, -1);
-        });
-    }
-
-    @Test
-    void iconGreaterThanNine() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new Inventor(1, 10);
-        });
-    }
-
-    @Test
-    void negativeIconWithNMin() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new Inventor(1, -1, 3);
-        });
-    }
-
-    @Test
-    void iconGreaterThanNineWithNMin() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new Inventor(1, 10, 3);
-        });
-    }
-
     @Test
     void constructorWithIdIMGTest() {
         Inventor i = new Inventor("inventor1", 1, 5);
 
+        assertEquals("inventor1", i.getIdIMG());
         assertEquals(1, i.getEra());
         assertEquals(CharacterType.INVENTOR, i.getType());
         assertEquals(5, i.Icon());
@@ -119,47 +103,70 @@ class InventorTest {
     }
 
     @Test
-    void constructorWithIdIMGAndToStringBoardCoverageTest() {
+    void constructorWithIdIMGAndNMinTest() {
-        // Valid constructor with idIMG
+        Inventor i = new Inventor("inventor1", 1, 5, 3);
-        Inventor i1 = new Inventor("inventor1", 1, 5);
 
-        assertEquals(1, i1.getEra());
+        assertEquals("inventor1", i.getIdIMG());
-        assertEquals(CharacterType.INVENTOR, i1.getType());
+        assertEquals(1, i.getEra());
-        assertEquals(5, i1.Icon());
+        assertEquals(CharacterType.INVENTOR, i.getType());
-        assertEquals(0, i1.getNMin());
+        assertEquals(5, i.Icon());
-        assertFalse(i1.IsEventCard());
+        assertEquals(3, i.getNMin());
+        assertFalse(i.IsEventCard());
+    }
 
-        // Valid constructor with idIMG and nMin
+    @Test
-        Inventor i2 = new Inventor("inventor2", 1, 7, 3);
+    void negativeIcon() {
+        assertThrows(IllegalArgumentException.class, () ->
+                new Inventor(1, -1)
+        );
+    }
 
-        assertEquals(1, i2.getEra());
+    @Test
-        assertEquals(CharacterType.INVENTOR, i2.getType());
+    void iconGreaterThanNine() {
-        assertEquals(7, i2.Icon());
+        assertThrows(IllegalArgumentException.class, () ->
-        assertEquals(3, i2.getNMin());
+                new Inventor(1, 10)
-        assertFalse(i2.IsEventCard());
+        );
+    }
 
-        // Invalid icon with idIMG constructor
+    @Test
-        assertThrows(IllegalArgumentException.class, () -> {
+    void negativeIconWithNMin() {
-            new Inventor("inventor3", 1, -1);
+        assertThrows(IllegalArgumentException.class, () ->
-        });
+                new Inventor(1, -1, 3)
+        );
+    }
 
-        assertThrows(IllegalArgumentException.class, () -> {
+    @Test
-            new Inventor("inventor4", 1, 10);
+    void iconGreaterThanNineWithNMin() {
-        });
+        assertThrows(IllegalArgumentException.class, () ->
+                new Inventor(1, 10, 3)
+        );
+    }
 
-        // Invalid icon with idIMG and nMin constructor
+    @Test
-        assertThrows(IllegalArgumentException.class, () -> {
+    void negativeIconWithIdIMG() {
-            new Inventor("inventor5", 1, -1, 3);
+        assertThrows(IllegalArgumentException.class, () ->
-        });
+                new Inventor("inventor1", 1, -1)
+        );
+    }
 
-        assertThrows(IllegalArgumentException.class, () -> {
+    @Test
-            new Inventor("inventor6", 1, 10, 3);
+    void iconGreaterThanNineWithIdIMG() {
-        });
+        assertThrows(IllegalArgumentException.class, () ->
+                new Inventor("inventor1", 1, 10)
+        );
+    }
 
-        // toStringBoard coverage
+    @Test
-        String s = i1.toStringBoard();
+    void negativeIconWithIdIMGAndNMin() {
+        assertThrows(IllegalArgumentException.class, () ->
+                new Inventor("inventor1", 1, -1, 3)
+        );
+    }
 
-        assertNotNull(s);
+    @Test
-        assertTrue(s.contains("I_ID:5"));
+    void iconGreaterThanNineWithIdIMGAndNMin() {
+        assertThrows(IllegalArgumentException.class, () ->
+                new Inventor("inventor1", 1, 10, 3)
+        );
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/ShamanTest.java

@@ -25,13 +25,23 @@ class ShamanTest {
         assertEquals("⎕: *:" + s.getIcon(), str);
     }
 
+    @Test
+    void testToStringBoard() {
+        Shaman s = new Shaman(1, 4);
+        String str = s.toStringBoard();
+
+        assertNotNull(str);
+        assertTrue(str.contains("*:4"));
+    }
+
     @Test
     void testClone() {
-        Shaman s = new Shaman(1, 4, 3);
+        Shaman s = new Shaman("shaman1", 1, 4, 3);
         Shaman clone = (Shaman) s.clone();
 
         assertNotNull(clone);
         assertNotSame(s, clone);
+        assertEquals(s.getIdIMG(), clone.getIdIMG());
         assertEquals(s.getEra(), clone.getEra());
         assertEquals(s.getType(), clone.getType());
         assertEquals(s.getIcon(), clone.getIcon());
@@ -39,9 +49,9 @@ class ShamanTest {
     }
 
     @Test
-    void insert() {
+    void insertTest() {
         Player p = new Player("test");
-        Shaman s = new Shaman(1, 4);
+        Shaman s = new Shaman(1, 4, 5);
 
         assertEquals(0, p.shamans.size());
 
@@ -50,11 +60,12 @@ class ShamanTest {
         assertEquals(1, p.shamans.size());
         assertTrue(p.shamans.contains(s));
 
-        Shaman s2 = new Shaman(1, 6);
+        Shaman insertedShaman = p.shamans.get(0);
-        s2.insert(p);
+        assertSame(s, insertedShaman);
-
+        assertEquals(1, insertedShaman.getEra());
-        assertEquals(2, p.shamans.size());
+        assertEquals(5, insertedShaman.getNMin());
-        assertTrue(p.shamans.contains(s2));
+        assertEquals(CharacterType.SHAMAN, insertedShaman.getType());
+        assertEquals(4, insertedShaman.getIcon());
     }
 
     @Test
@@ -78,4 +89,28 @@ class ShamanTest {
         assertEquals(3, s.getNMin());
         assertFalse(s.IsEventCard());
     }
+
+    @Test
+    void constructorWithIdIMGTest() {
+        Shaman s = new Shaman("shaman1", 1, 4);
+
+        assertEquals("shaman1", s.getIdIMG());
+        assertEquals(1, s.getEra());
+        assertEquals(CharacterType.SHAMAN, s.getType());
+        assertEquals(4, s.getIcon());
+        assertEquals(0, s.getNMin());
+        assertFalse(s.IsEventCard());
+    }
+
+    @Test
+    void constructorWithIdIMGAndNMinTest() {
+        Shaman s = new Shaman("shaman1", 1, 4, 3);
+
+        assertEquals("shaman1", s.getIdIMG());
+        assertEquals(1, s.getEra());
+        assertEquals(CharacterType.SHAMAN, s.getType());
+        assertEquals(4, s.getIcon());
+        assertEquals(3, s.getNMin());
+        assertFalse(s.IsEventCard());
+    }
 }