2210892
/
WIZARD_PR2_DOP22
forked from 2211945/WIZARD_PR2_DOP
1
0
Fork 0
Code Pull Requests Activity

Merge pull request 'iss#6' (#43) from iss#6 into main 

Reviewed-on: 2211945/WIZARD_PR2_DOP#43
Reviewed-by: Kai Sellmann <2210892@stud.hs-mannheim.de>
Kai Sellmann 2023-11-07 10:38:02 +01:00
parent f13e1208ba 9fa2f7f4ae
commit 3056aed05c
6 changed files with 313 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
Domain/Block/Block.java
View File

@ -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() {
return null;
public void addZeile(Blockzeile blockzeile) {
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
}

48
Domain/Block/Blockeintrag.java
View File

@ -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() + " | ";
}
}

42
Domain/Block/Blockzeile.java
View File

@ -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<Blockeintrag> 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;
}
}

92
Test/Domain/Block/BlockTest.java
View File

@ -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);
}
}

35
Test/Domain/Block/BlockeintragTest.java
View File

@ -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));
}
}

98
Test/Domain/Block/BlockzeileTest.java
View File

@ -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());
}
}