From 4030351fde34ffe213f85471f50fee724f210e4c Mon Sep 17 00:00:00 2001 From: Mohammad Hawrami <2210970@stud.hs-mannheim.de> Date: Sun, 5 Nov 2023 20:40:16 +0100 Subject: [PATCH 1/3] Erweiterung der Klassen Block, Blockeintrag und Blockzeile und fertigung des Testes Blockeintrag --- Domain/Block/Block.java | 21 +++++++--- Domain/Block/Blockeintrag.java | 15 ++++--- Domain/Block/Blockzeile.java | 39 +++++++++++++------ Test/Domain/Block/BlockeintragTest.java | 52 ++++++++++++++++++++++++- 4 files changed, 105 insertions(+), 22 deletions(-) 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..08a1177 100644 --- a/Domain/Block/Blockeintrag.java +++ b/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; - public int stiche; - + private int punkte; + 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; } - } diff --git a/Domain/Block/Blockzeile.java b/Domain/Block/Blockzeile.java index 1bde72b..a179732 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,20 @@ 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) { + 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) { - - for (int i = 0; i < eintraege.length; i++) { - if (eintraege[i] == null) { - eintraege[i] = be; - } + if(eintraege != null){ + eintraege.add(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; + } } diff --git a/Test/Domain/Block/BlockeintragTest.java b/Test/Domain/Block/BlockeintragTest.java index 128d0a2..20686c4 100644 --- a/Test/Domain/Block/BlockeintragTest.java +++ b/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)); + } } -- 2.43.0 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 2/3] 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 -- 2.43.0 From 4b4ebbfbe47dc43431fac01fecfedc34dc9dd498 Mon Sep 17 00:00:00 2001 From: Mohammad Hawrami <2210970@stud.hs-mannheim.de> Date: Tue, 7 Nov 2023 10:31:04 +0100 Subject: [PATCH 3/3] Update Block und Blocktest --- Domain/Block/Blockeintrag.java | 14 +++++++------- Test/Domain/Block/BlockeintragTest.java | 3 +-- Test/Domain/Block/BlockzeileTest.java | 22 ++++++++++------------ 3 files changed, 18 insertions(+), 21 deletions(-) diff --git a/Domain/Block/Blockeintrag.java b/Domain/Block/Blockeintrag.java index fc79e1b..3576c34 100644 --- a/Domain/Block/Blockeintrag.java +++ b/Domain/Block/Blockeintrag.java @@ -13,18 +13,18 @@ import java.util.Objects; public class Blockeintrag { private int punkte; private int stiche; - private Spieler spieler; + private Spieler id; public Blockeintrag() { } - public Blockeintrag(int punkte, int stiche, Spieler spieler) { + 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.spieler = spieler; + this.id = id; } public int getPunkte() { @@ -46,8 +46,8 @@ public class Blockeintrag { this.punkte = punkte; } - public Spieler getSpieler() { - return spieler; + public Spieler getId() { + return id; } @Override @@ -61,12 +61,12 @@ public class Blockeintrag { Blockeintrag andererEintrag = (Blockeintrag) ob; return this.punkte == andererEintrag.punkte && this.stiche == andererEintrag.stiche - && Objects.equals(this.spieler, andererEintrag.spieler); + && Objects.equals(this.id, andererEintrag.id); } @Override public int hashCode() { - return Objects.hash(punkte, stiche, spieler); + return Objects.hash(punkte, stiche, id); } @Override diff --git a/Test/Domain/Block/BlockeintragTest.java b/Test/Domain/Block/BlockeintragTest.java index 9630945..6182c8b 100644 --- a/Test/Domain/Block/BlockeintragTest.java +++ b/Test/Domain/Block/BlockeintragTest.java @@ -7,7 +7,6 @@ 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; @@ -36,7 +35,7 @@ public class BlockeintragTest { } //Exception Test hier schreiben - //@Test + @Test public void testNegativeStiche() throws Exception { assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3, null)); assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1, null)); diff --git a/Test/Domain/Block/BlockzeileTest.java b/Test/Domain/Block/BlockzeileTest.java index 7d2399f..f5fa532 100644 --- a/Test/Domain/Block/BlockzeileTest.java +++ b/Test/Domain/Block/BlockzeileTest.java @@ -9,11 +9,9 @@ package Test.Domain.Block; 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(); @@ -41,25 +39,25 @@ public class BlockzeileTest { 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]); + 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[2]); - assertEquals("addEintrag: 2 Eintrag", e4, daten[3]); + 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[4]); - assertEquals("addEintrag: 3 Eintrag", e6, daten[5]); + assertEquals("addEintrag: 3 Eintrag", e5, daten[5]); + assertEquals("addEintrag: 3 Eintrag", e6, daten[6]); } //Überprüfung ob Daten korrekt zurückgegeben werden @@ -71,9 +69,9 @@ public class BlockzeileTest { Blockeintrag[] daten = z1.getDaten(); - assertEquals(2, daten.length); - assertEquals(e1, daten[0]); - assertEquals(e2, daten[1]); + assertEquals(3, daten.length); + assertEquals(e1, daten[1]); + assertEquals(e2, daten[2]); z1.addEintrag(null); Blockeintrag[] daten1 = z1.getDaten(); -- 2.43.0