diff --git a/Domain/Block/Block.java b/Domain/Block/Block.java index bdf34d0..b32947c 100644 --- a/Domain/Block/Block.java +++ b/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 zeilen; + public Block(){ + this.zeilen = new ArrayList<>(); } - public Blockzeile[] getDaten() { - return null; + public void addZeile(Blockzeile blockzeile) { + zeilen.add(blockzeile); } - //neues Kommentar -} + + 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]); + } +} \ No newline at end of file diff --git a/Domain/Block/Blockeintrag.java b/Domain/Block/Blockeintrag.java index e8eb99c..3576c34 100644 --- a/Domain/Block/Blockeintrag.java +++ b/Domain/Block/Blockeintrag.java @@ -6,17 +6,25 @@ written on: 05 / 10 / 2023 at: 23:44 */ package Domain.Block; -public class Blockeintrag { - public int punkte; - public int stiche; +import Domain.Spieler; +import java.util.Objects; + +public class Blockeintrag { + private int punkte; + private int stiche; + private Spieler id; public Blockeintrag() { } - public Blockeintrag(int punkte, int stiche) { - this.punkte = punkte; + public Blockeintrag(int punkte, int stiche, Spieler id) { + if(stiche < 0){ + throw new IllegalArgumentException("Ihre Stiche dürfen nicht im Negativen bereich sein"); + } this.stiche = stiche; + this.punkte = punkte; + this.id = id; } public int getPunkte() { @@ -28,6 +36,9 @@ 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; } @@ -35,4 +46,31 @@ public class Blockeintrag { this.punkte = punkte; } + public Spieler getId() { + return id; + } + + @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.id, andererEintrag.id); + } + + @Override + public int hashCode() { + return Objects.hash(punkte, stiche, id); + } + + @Override + public String toString() { + return getPunkte() + ", S: " + getStiche() + " | "; + } } diff --git a/Domain/Block/Blockzeile.java b/Domain/Block/Blockzeile.java index 1bde72b..60a454a 100644 --- a/Domain/Block/Blockzeile.java +++ b/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,21 @@ public class Blockzeile { /*------------------------------------------*/ private int rundenNummer; - private Blockeintrag[] eintraege; + private ArrayList eintraege; /*------------------------------------------*/ // Konstruktoren (default und spezifische) /*------------------------------------------*/ - public Blockzeile(int rundenNummer, int spielerAnzahl) { - this.rundenNummer = rundenNummer; - this.eintraege = new Blockeintrag[spielerAnzahl]; + public Blockzeile(){ + } + public Blockzeile(int rundenNummer, Blockeintrag eintrag) { + this.rundenNummer = rundenNummer; + this.eintraege = new ArrayList<>(); + addEintrag(eintrag); + } /*------------------------------------------*/ // statische Methoden /*------------------------------------------*/ @@ -39,7 +45,13 @@ public class Blockzeile { /*------------------------------------------*/ // Getter und Setter /*------------------------------------------*/ + public int getRundenNummer() { + return rundenNummer; + } + public void setRundenNummer(int rundenNummer) { + this.rundenNummer = rundenNummer; + } /*------------------------------------------*/ // @Overrides /*------------------------------------------*/ @@ -48,21 +60,27 @@ public class Blockzeile { // öffentliche Methodes /*------------------------------------------*/ - public void addEintrag(Blockeintrag be) { - - for (int i = 0; i < eintraege.length; i++) { - if (eintraege[i] == null) { - eintraege[i] = be; - } + public void addEintrag(Blockeintrag eintrag) { + if(eintraege != null){ + eintraege.add(eintrag); } } 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; + } } diff --git a/Test/Domain/Block/BlockTest.java b/Test/Domain/Block/BlockTest.java index 4956d1f..94fd112 100644 --- a/Test/Domain/Block/BlockTest.java +++ b/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); + } +} \ No newline at end of file diff --git a/Test/Domain/Block/BlockeintragTest.java b/Test/Domain/Block/BlockeintragTest.java index 128d0a2..6182c8b 100644 --- a/Test/Domain/Block/BlockeintragTest.java +++ b/Test/Domain/Block/BlockeintragTest.java @@ -6,6 +6,39 @@ 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; +import static org.junit.Assert.assertTrue; + +public class BlockeintragTest { + @Test + public void getPunkteTest(){ + Blockeintrag eintrag = new Blockeintrag(20,0,null); + assertTrue((eintrag.getPunkte() == 20)); + eintrag.setPunkte(30); + assertTrue((eintrag.getPunkte() == 30)); + eintrag.setPunkte(40); + assertTrue((eintrag.getPunkte()== 40)); + } + + @Test + public void getStiche() { + Blockeintrag eintrag = new Blockeintrag(30,1,null); + assertEquals(1, eintrag.getStiche()); + eintrag.setStiche(2); + assertEquals(2, eintrag.getStiche()); + eintrag.setStiche(3); + assertEquals(3, eintrag.getStiche()); + } + + //Exception Test hier schreiben + @Test + public void testNegativeStiche() throws Exception { + assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3, null)); + assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1, null)); + assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(10, -4, null)); + } } diff --git a/Test/Domain/Block/BlockzeileTest.java b/Test/Domain/Block/BlockzeileTest.java index 1ff7487..f5fa532 100644 --- a/Test/Domain/Block/BlockzeileTest.java +++ b/Test/Domain/Block/BlockzeileTest.java @@ -6,6 +6,102 @@ 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 org.junit.Test; -} +import static org.junit.Assert.assertEquals; + +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", 3, daten.length); + assertEquals("addEintrag: 1 Eintrag", e1, daten[1]); + assertEquals("addEintrag: 1 Eintrag", e2, daten[2]); + + //2 Eintrag + z1.addEintrag(e3); + z1.addEintrag(e4); + daten = z1.getDaten(); + assertEquals("addEintrag: 2 Eintrag", 5, daten.length); + assertEquals("addEintrag: 2 Eintrag", e3, daten[3]); + assertEquals("addEintrag: 2 Eintrag", e4, daten[4]); + + //3 Eintrag + z1.addEintrag(e5); + z1.addEintrag(e6); + daten = z1.getDaten(); + assertEquals("addEintrag: 3 Eintrag", 7, daten.length); + assertEquals("addEintrag: 3 Eintrag", e5, daten[5]); + assertEquals("addEintrag: 3 Eintrag", e6, daten[6]); + } + + //Überprüfung ob Daten korrekt zurückgegeben werden + @Test + public void getDatenTest() { + + z1.addEintrag(e1); + z1.addEintrag(e2); + + Blockeintrag[] daten = z1.getDaten(); + + assertEquals(3, daten.length); + assertEquals(e1, daten[1]); + assertEquals(e2, daten[2]); + + 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()); + } +} \ No newline at end of file