Erweiterung der Klassen Block, Blockeintrag und Blockzeile und fertigung des Testes Blockeintrag,Block,Blockzeile

Domain/Block/Blockeintrag.java

@@ -6,20 +6,25 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
+import Domain.Spieler;
+
+import java.util.Objects;
+
 public class Blockeintrag {
     private int punkte;
     private int stiche;
-    private int  spielerId;
+    private Spieler spieler;
     public Blockeintrag() {
 
     }
 
-    public Blockeintrag(int punkte, int stiche) {
+    public Blockeintrag(int punkte, int stiche, Spieler spieler) {
         if(stiche < 0){
             throw new IllegalArgumentException("Ihre Stiche dürfen nicht im Negativen bereich sein");
         }
         this.stiche = stiche;
         this.punkte = punkte;
+        this.spieler = spieler;
     }
 
     public int getPunkte() {
@@ -40,4 +45,32 @@ public class Blockeintrag {
     public void setPunkte(int punkte) {
         this.punkte = punkte;
     }
+
+    public Spieler getSpieler() {
+        return spieler;
+    }
+
+    @Override
+    public boolean equals(Object ob){
+        if (this == ob) {
+            return true;
+        }
+        if (ob == null || getClass() != ob.getClass()) {
+            return false;
+        }
+
+        Blockeintrag andererEintrag = (Blockeintrag) ob;
+        return this.punkte == andererEintrag.punkte && this.stiche == andererEintrag.stiche
+                && Objects.equals(this.spieler, andererEintrag.spieler);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(punkte, stiche, spieler);
+    }
+
+    @Override
+    public String toString() {
+        return getPunkte() + ", S: " + getStiche() + " | ";
+    }
 }

Domain/Block/Blockzeile.java

@@ -33,9 +33,10 @@ public class Blockzeile {
 
     }
 
-    public Blockzeile(int rundenNummer) {
+    public Blockzeile(int rundenNummer, Blockeintrag eintrag) {
         this.rundenNummer = rundenNummer;
         this.eintraege = new ArrayList<>();
+        addEintrag(eintrag);
     }
     /*------------------------------------------*/
     // statische Methoden
@@ -59,9 +60,9 @@ public class Blockzeile {
     // öffentliche Methodes
     /*------------------------------------------*/
 
-    public void addEintrag(Blockeintrag be) {
+    public void addEintrag(Blockeintrag eintrag) {
         if(eintraege != null){
-            eintraege.add(be);
+            eintraege.add(eintrag);
         }
     }
 

Test/Domain/Block/BlockTest.java

@@ -6,6 +6,96 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockTest {
+import Domain.Block.Block;
+import Domain.Block.Blockeintrag;
+import Domain.Block.Blockzeile;
+import Domain.Enums.Geschlecht;
+import Facade.Spiel;
+import org.junit.Test;
 
-}
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+
+public class BlockTest {
+    Block block = new Block();
+    Blockeintrag b1 = new Blockeintrag(20,0,null);
+    Blockeintrag b2 = new Blockeintrag(30,1,null);
+    Blockeintrag b3 = new Blockeintrag(40,2,null);
+    Blockeintrag b4 = new Blockeintrag(20,0,null);
+    Blockeintrag b5 = new Blockeintrag(30,1,null);
+    Blockeintrag b6 = new Blockeintrag(40,2,null);
+
+    Blockzeile z1 = new Blockzeile(1,b1);
+    Blockzeile z2 = new Blockzeile(2,b2);
+    Blockzeile z3 = new Blockzeile(3, b3);
+    Blockzeile z4 = new Blockzeile(1,b1);
+    Blockzeile z5 = new Blockzeile(2,b2);
+    Blockzeile z6 = new Blockzeile(3, b3);
+
+    /**
+     * Testet die Methode addZeile in der Block-Klasse.
+     * Überprüft, ob die Anzahl der Zeilen im Block nach dem Hinzufügen korrekt ist
+     * und ob die hinzugefügte Zeile an der richtigen Position im Datenarray steht.
+     */
+    @Test
+    public void addZeileTest() {
+        block.addZeile(z1);
+        block.addZeile(z2);
+        block.addZeile(z3);
+
+        z1.addEintrag(b1);
+        z1.addEintrag(b2);
+        z1.addEintrag(b3);
+        z2.addEintrag(b1);
+        z2.addEintrag(b2);
+        z2.addEintrag(b3);
+        z3.addEintrag(b1);
+        z3.addEintrag(b2);
+        z3.addEintrag(b3);
+
+        assertEquals(3,block.getDaten().length);
+        assertTrue((z1 == block.getDaten()[0]) &&
+                (z2 == block.getDaten()[1]) && (z3 == block.getDaten()[2]));
+
+    }
+
+    /**
+     * Testet die Methode getDaten der Klasse Block. Überprüft, ob die Daten im
+     * Block korrekt abgerufen werden können.
+     */
+    @Test
+    public void getDatenTest() {
+        block.addZeile(z4);
+        block.addZeile(z5);
+        block.addZeile(z6);
+
+        z1.addEintrag(b4);
+        z1.addEintrag(b5);
+        z1.addEintrag(b6);
+        z2.addEintrag(b4);
+        z2.addEintrag(b5);
+        z2.addEintrag(b6);
+        z3.addEintrag(b4);
+        z3.addEintrag(b5);
+        z3.addEintrag(b6);
+
+        assertTrue((block.getDaten()[0].getDaten()[0].getPunkte() ==20)
+        && (block.getDaten()[0].getDaten()[0].getStiche() == 0)
+        && (block.getDaten()[1].getDaten()[0].getPunkte() == 30)
+        && (block.getDaten()[1].getDaten()[0].getStiche() == 1)
+        && (block.getDaten()[2].getDaten()[0].getPunkte() == 40)
+        && (block.getDaten()[2].getDaten()[0].getStiche() == 2));
+
+    }
+
+    /**
+     * Testet die Methode getDaten der Klasse Block für einen leeren Block.
+     * Überprüft, ob für einen leeren Block ein leeres Datenarray zurückgegeben
+     * wird.
+     */
+    @Test
+    public void getDatenTestLeererBlock(){
+        Block block2 = new Block();
+        assertEquals(0, block2.getDaten().length);
+    }
+}

Test/Domain/Block/BlockeintragTest.java

@@ -7,55 +7,39 @@ written on: 10 / 10 / 2023 at: 21:17
 package Test.Domain.Block;
 
 import Domain.Block.Blockeintrag;
+import org.junit.Assert;
 import org.junit.Test;
 
 import static junit.framework.TestCase.assertEquals;
 import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 public class BlockeintragTest {
     @Test
-    public void testNormalerEintrag() {
+    public void getPunkteTest(){
-        Blockeintrag e = new Blockeintrag(0,2);
+        Blockeintrag eintrag = new Blockeintrag(20,0,null);
-        assertEquals(0, e.getPunkte());
+        assertTrue((eintrag.getPunkte() == 20));
-        e.setPunkte(10);
+        eintrag.setPunkte(30);
-        assertEquals(10, e.getPunkte());
+        assertTrue((eintrag.getPunkte() == 30));
-        e.setPunkte(110);
+        eintrag.setPunkte(40);
-        assertEquals(110, e.getPunkte());
+        assertTrue((eintrag.getPunkte()== 40));
-        e.setPunkte(130);
-        assertEquals(130, e.getPunkte());
-        e.setPunkte(200);
-        assertEquals(200, e.getPunkte());
-
-        assertEquals(2, e.getStiche());
-        e.setStiche(20);
-        assertEquals(20, e.getStiche());
-        e.setStiche(17);
-        assertEquals(17, e.getStiche());
-        e.setStiche(34);
-        assertEquals(34, e.getStiche());
-        e.setStiche(19);
-        assertEquals(19, e.getStiche());
     }
 
     @Test
-    public void testNegativePunkte() {
+    public void getStiche() {
-        Blockeintrag e = new Blockeintrag(-50, 3);
+        Blockeintrag eintrag = new Blockeintrag(30,1,null);
-        assertEquals(-50, e.getPunkte());
+        assertEquals(1, eintrag.getStiche());
-        e.setPunkte(-10);
+        eintrag.setStiche(2);
-        assertEquals(-10, e.getPunkte());
+        assertEquals(2, eintrag.getStiche());
-        e.setPunkte(-60);
+        eintrag.setStiche(3);
-        assertEquals(-60, e.getPunkte());
+        assertEquals(3, eintrag.getStiche());
-        e.setPunkte(-80);
-        assertEquals(-80, e.getPunkte());
-        e.setPunkte(-200);
-        assertEquals(-200, e.getPunkte());
     }
 
     //Exception Test hier schreiben
-    @Test
+    //@Test
     public void testNegativeStiche() throws Exception {
-        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3, null));
-        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1, null));
-        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(10, -4));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(10, -4, null));
     }
 }

Test/Domain/Block/BlockzeileTest.java

@@ -6,6 +6,104 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockzeileTest {
+import Domain.Block.Block;
+import Domain.Block.Blockeintrag;
+import Domain.Block.Blockzeile;
+import com.sun.source.tree.BlockTree;
+import org.junit.Test;
 
-}
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class BlockzeileTest {
+    Block b = new Block();
+    Blockeintrag e1 = new Blockeintrag(20,0,null);
+    Blockeintrag e2 = new Blockeintrag(30,1,null);
+    Blockeintrag e3 = new Blockeintrag(40,2,null);
+    Blockeintrag e4 = new Blockeintrag(50,2, null);
+    Blockeintrag e5 = new Blockeintrag(50, 2, null);
+    Blockeintrag e6 = new Blockeintrag(40, 1, null);
+    Blockzeile z1 = new Blockzeile(1, e1);
+    Blockzeile z2 = new Blockzeile(2, e2);
+    Blockzeile z3 = new Blockzeile(3, e3);
+
+    /**
+     * testet addEintrag
+     * Anmerkung assertEquals überprüft nicht ob der Eintrag richtig ist sondern ob das
+     * Objekt eintrag1 im array liegt Eintrag wird in Blockeintrag auf Richtigkeit
+     * getestet
+     */
+    @Test
+    public void addEintragTest() {
+        Blockeintrag[] daten;
+
+        //1 Eintrag
+        z1.addEintrag(e1);
+        z1.addEintrag(e2);
+        daten = z1.getDaten();
+        assertEquals("addEintrag: 1 Eintrag", 2, daten.length);
+        assertEquals("addEintrag: 1 Eintrag", e1, daten[0]);
+        assertEquals("addEintrag: 1 Eintrag", e2, daten[1]);
+
+        //2 Eintrag
+        z1.addEintrag(e3);
+        z1.addEintrag(e4);
+        daten = z1.getDaten();
+        assertEquals("addEintrag: 2 Eintrag", 5, daten.length);
+        assertEquals("addEintrag: 2 Eintrag", e3, daten[2]);
+        assertEquals("addEintrag: 2 Eintrag", e4, daten[3]);
+
+        //3 Eintrag
+        z1.addEintrag(e5);
+        z1.addEintrag(e6);
+        daten = z1.getDaten();
+        assertEquals("addEintrag: 3 Eintrag", 7, daten.length);
+        assertEquals("addEintrag: 3 Eintrag", e5, daten[4]);
+        assertEquals("addEintrag: 3 Eintrag", e6, daten[5]);
+    }
+
+    //Überprüfung ob Daten korrekt zurückgegeben werden
+    @Test
+    public void getDatenTest() {
+
+        z1.addEintrag(e1);
+        z1.addEintrag(e2);
+
+        Blockeintrag[] daten = z1.getDaten();
+
+        assertEquals(2, daten.length);
+        assertEquals(e1, daten[0]);
+        assertEquals(e2, daten[1]);
+
+        z1.addEintrag(null);
+        Blockeintrag[] daten1 = z1.getDaten();
+    }
+
+    @Test
+    public void duplikateRunde() throws Exception{
+        Blockeintrag e1 = new Blockeintrag(30,1,null);
+        Blockeintrag e2 = new Blockeintrag(20,0,null);
+
+        Blockzeile z1 = new Blockzeile(4, e1);
+        Blockzeile z2 = new Blockzeile(4, e2);
+    }
+
+    @Test
+    public void invalidRunde() throws Exception{
+        Blockzeile z4 = new Blockzeile(-1, e1);
+    }
+
+    @Test
+    public void invalidRunde2() throws Exception{
+        Blockzeile z5 = new Blockzeile(-3, e2);
+    }
+
+    @Test
+    public void getRundenNummer(){
+        assertEquals(3, z3.getRundenNummer());
+        z3.setRundenNummer(4);
+        assertEquals(4, z3.getRundenNummer());
+        z3.setRundenNummer(5);
+        assertEquals(5, z3.getRundenNummer());
+    }
+}