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

Domain/Block/Block.java

@@ -6,13 +6,24 @@ written on: 05 / 10 / 2023 at: 23:43
 */
 package Domain.Block;
 
+import java.util.ArrayList;
+
 public class Block {
-    public void addZeile(){
+    private ArrayList<Blockzeile> zeilen;
 
+    public Block(){
+        this.zeilen = new ArrayList<>();
     }
 
-    public Blockzeile[] getDaten() {
+    public void addZeile(Blockzeile blockzeile) {
-        return null;
+        zeilen.add(blockzeile);
+    }
+
+    public Blockzeile[] getDaten(){
+        if(zeilen.isEmpty()){
+            System.out.println("Die Liste der Blockzeilen ist Leer. ");
+            return zeilen.toArray(new Blockzeile[0]);
+        }
+        return zeilen.toArray(new Blockzeile[0]);
     }
-    //neues Kommentar
 }

Domain/Block/Blockeintrag.java

@@ -7,16 +7,19 @@ written on: 05 / 10 / 2023 at: 23:44
 package Domain.Block;
 
 public class Blockeintrag {
-    public int punkte;
+    private int punkte;
-    public int stiche;
+    private int stiche;
-
+    private int  spielerId;
     public Blockeintrag() {
 
     }
 
     public Blockeintrag(int punkte, int stiche) {
-        this.punkte = punkte;
+        if(stiche < 0){
+            throw new IllegalArgumentException("Ihre Stiche dürfen nicht im Negativen bereich sein");
+        }
         this.stiche = stiche;
+        this.punkte = punkte;
     }
 
     public int getPunkte() {
@@ -28,11 +31,13 @@ public class Blockeintrag {
     }
 
     public void setStiche(int stiche) {
+        if (stiche < 0){
+            throw new IllegalArgumentException("Ihre Stich dürfen nicht im Negative bereich sein");
+        }
         this.stiche = stiche;
     }
 
     public void setPunkte(int punkte) {
         this.punkte = punkte;
     }
-
 }

Domain/Block/Blockzeile.java

@@ -6,6 +6,8 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
+import java.util.ArrayList;
+
 public class Blockzeile {
 
     /*------------------------------------------*/
@@ -21,17 +23,20 @@ public class Blockzeile {
     /*------------------------------------------*/
 
     private int rundenNummer;
-    private Blockeintrag[] eintraege;
+    private ArrayList<Blockeintrag> eintraege;
 
     /*------------------------------------------*/
     // Konstruktoren (default und spezifische)
     /*------------------------------------------*/
 
-    public Blockzeile(int rundenNummer, int spielerAnzahl) {
+    public Blockzeile(){
-        this.rundenNummer = rundenNummer;
+
-        this.eintraege = new Blockeintrag[spielerAnzahl];
     }
 
+    public Blockzeile(int rundenNummer) {
+        this.rundenNummer = rundenNummer;
+        this.eintraege = new ArrayList<>();
+    }
     /*------------------------------------------*/
     // statische Methoden
     /*------------------------------------------*/
@@ -39,7 +44,13 @@ public class Blockzeile {
     /*------------------------------------------*/
     // Getter und Setter
     /*------------------------------------------*/
+    public int getRundenNummer() {
+        return rundenNummer;
+    }
 
+    public void setRundenNummer(int rundenNummer) {
+        this.rundenNummer = rundenNummer;
+    }
     /*------------------------------------------*/
     // @Overrides
     /*------------------------------------------*/
@@ -49,20 +60,26 @@ public class Blockzeile {
     /*------------------------------------------*/
 
     public void addEintrag(Blockeintrag be) {
-
+        if(eintraege != null){
-        for (int i = 0; i < eintraege.length; i++) {
+            eintraege.add(be);
-            if (eintraege[i] == null) {
-                eintraege[i] = be;
-            }
         }
     }
 
     public Blockeintrag[] getDaten() {
-        return eintraege;
+        return eintraege.toArray(new Blockeintrag[0]);
     }
-
     /*------------------------------------------*/
     // Hilfsmethoden (privat)
     /*------------------------------------------*/
 
+    public Blockeintrag[] getValidDaten() {
+        Blockeintrag[] dataArray = getDaten();
+
+        for (Blockeintrag eintrag : dataArray) {
+            if (eintrag == null) {
+                throw new IllegalStateException("Das Array ist leer");
+            }
+        }
+        return dataArray;
+    }
 }

Test/Domain/Block/BlockeintragTest.java

@@ -6,6 +6,56 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockeintragTest {
+import Domain.Block.Blockeintrag;
+import org.junit.Test;
 
+import static junit.framework.TestCase.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+public class BlockeintragTest {
+    @Test
+    public void testNormalerEintrag() {
+        Blockeintrag e = new Blockeintrag(0,2);
+        assertEquals(0, e.getPunkte());
+        e.setPunkte(10);
+        assertEquals(10, e.getPunkte());
+        e.setPunkte(110);
+        assertEquals(110, e.getPunkte());
+        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() {
+        Blockeintrag e = new Blockeintrag(-50, 3);
+        assertEquals(-50, e.getPunkte());
+        e.setPunkte(-10);
+        assertEquals(-10, e.getPunkte());
+        e.setPunkte(-60);
+        assertEquals(-60, e.getPunkte());
+        e.setPunkte(-80);
+        assertEquals(-80, e.getPunkte());
+        e.setPunkte(-200);
+        assertEquals(-200, e.getPunkte());
+    }
+
+    //Exception Test hier schreiben
+    @Test
+    public void testNegativeStiche() throws Exception {
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(10, -4));
+    }
 }