forked from 2211945/WIZARD_PR2_DOP
Erweiterung der Klassen Block, Blockeintrag und Blockzeile und fertigung des Testes Blockeintrag,Block,Blockzeile
parent
4030351fde
commit
5de20bcf4c
|
|
@ -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() + " | ";
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,6 +6,96 @@ written on: 10 / 10 / 2023 at: 21:17
|
|||
*/
|
||||
package Test.Domain.Block;
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue