From 5de20bcf4c7bb6218e11275a1c52a28d9e87c6b0 Mon Sep 17 00:00:00 2001 From: Mohammad Hawrami <2210970@stud.hs-mannheim.de> Date: Tue, 7 Nov 2023 09:54:07 +0100 Subject: [PATCH] Erweiterung der Klassen Block, Blockeintrag und Blockzeile und fertigung des Testes Blockeintrag,Block,Blockzeile --- Domain/Block/Blockeintrag.java | 37 ++++++++- Domain/Block/Blockzeile.java | 7 +- Test/Domain/Block/BlockTest.java | 94 +++++++++++++++++++++- Test/Domain/Block/BlockeintragTest.java | 56 +++++-------- Test/Domain/Block/BlockzeileTest.java | 102 +++++++++++++++++++++++- 5 files changed, 251 insertions(+), 45 deletions(-) diff --git a/Domain/Block/Blockeintrag.java b/Domain/Block/Blockeintrag.java index 08a1177..fc79e1b 100644 --- a/Domain/Block/Blockeintrag.java +++ b/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() + " | "; + } } diff --git a/Domain/Block/Blockzeile.java b/Domain/Block/Blockzeile.java index a179732..60a454a 100644 --- a/Domain/Block/Blockzeile.java +++ b/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); } } 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 20686c4..9630945 100644 --- a/Test/Domain/Block/BlockeintragTest.java +++ b/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() { - 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()); + 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 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()); + 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 + //@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)); + 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..7d2399f 100644 --- a/Test/Domain/Block/BlockzeileTest.java +++ b/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()); + } +} \ No newline at end of file