peet/oop-space
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chnaged test framework

Browse Source
This commit is contained in:
Johannes Schmelz
2026-06-15 21:35:55 +02:00
parent a6d7138af2
commit 5c5d36afa9
1 changed files with 316 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

711
src/ArenaTest.java
View File

@@ -1,445 +1,366 @@
import org.junit.jupiter.api.DisplayName; import org.junit.Test;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import java.util.List; import java.util.List;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.Assert.assertFalse;
import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@DisplayName("Generische Arena") public class ArenaTest {
class ArenaTest {
@Nested @Test
@DisplayName("Spieler-Arena") public void attackAllAttacksEveryPlayer() {
class PlayerArenaTests { // Arrange
Arena<Player> arena = new Arena<>();
@Test Player warrior = new Player(
@DisplayName( "Krieger",
"Ein Angriff wird auf alle Spieler angewendet" 100
) );
void attackAllAttacksEveryPlayer() {
// Arrange
Arena<Player> arena = new Arena<>();
Player warrior = new Player( Player mage = new Player(
"Krieger", "Magier",
100 70
); );
Player mage = new Player( arena.add(warrior);
"Magier", arena.add(mage);
70
);
arena.add(warrior); // Act
arena.add(mage); arena.attackAll(new SwordAttack());
// Act // Assert
arena.attackAll(new SwordAttack()); assertEquals(
70,
warrior.getHitPoints()
);
// Assert assertEquals(
assertAll( 40,
() -> assertEquals( mage.getHitPoints()
70, );
warrior.getHitPoints()
),
() -> assertEquals(
40,
mage.getHitPoints()
),
() -> assertFalse(
warrior.isDefeated()
),
() -> assertFalse(
mage.isDefeated()
)
);
}
@Test assertFalse(
@DisplayName( warrior.isDefeated()
"Dasselbe Objekt wird im Set nicht doppelt gespeichert" );
)
void samePlayerIsNotAddedTwice() {
// Arrange
Arena<Player> arena = new Arena<>();
Player player = new Player( assertFalse(
"Held", mage.isDefeated()
100 );
);
// Act
arena.add(player);
arena.add(player);
// Assert
assertEquals(
1,
arena.size()
);
}
} }
@Nested @Test
@DisplayName("Gegner-Arena") public void samePlayerIsNotAddedTwice() {
class EnemyArenaTests { // Arrange
Arena<Player> arena = new Arena<>();
@Test Player player = new Player(
@DisplayName( "Held",
"Double Dispatch wirkt für jeden Gegnertyp unterschiedlich" 100
) );
void fireSpellAffectsEnemyTypesDifferently() {
// Arrange
Arena<Enemy> arena = new Arena<>();
Skeleton skeleton = new Skeleton( // Act
"Knochensoldat", arena.add(player);
100 arena.add(player);
);
IceGolem iceGolem = new IceGolem( // Assert
"Frostwächter", assertEquals(
100 1,
); arena.size()
);
arena.add(skeleton);
arena.add(iceGolem);
// Act
arena.attackAll(new FireSpell());
// Assert
assertAll(
() -> assertEquals(
75,
skeleton.getHitPoints()
),
() -> assertEquals(
40,
iceGolem.getHitPoints()
)
);
}
@Test
@DisplayName(
"Ein Schwert wirkt ebenfalls abhängig vom Gegnertyp"
)
void swordAttackAffectsEnemyTypesDifferently() {
// Arrange
Arena<Enemy> arena = new Arena<>();
Skeleton skeleton = new Skeleton(
"Knochensoldat",
100
);
IceGolem iceGolem = new IceGolem(
"Frostwächter",
100
);
arena.add(skeleton);
arena.add(iceGolem);
// Act
arena.attackAll(new SwordAttack());
// Assert
assertAll(
() -> assertEquals(
60,
skeleton.getHitPoints()
),
() -> assertEquals(
85,
iceGolem.getHitPoints()
)
);
}
} }
@Nested @Test
@DisplayName("Gemischte Arena") public void fireSpellAffectsEnemyTypesDifferently() {
class MixedArenaTests { // Arrange
Arena<Enemy> arena = new Arena<>();
@Test Skeleton skeleton = new Skeleton(
@DisplayName( "Knochensoldat",
"Spieler und Gegner können gemeinsam angegriffen werden" 100
) );
void mixedArenaAttacksAllCharacterTypes() {
// Arrange
Arena<Character> arena = new Arena<>();
Player player = new Player( IceGolem iceGolem = new IceGolem(
"Held", "Frostwächter",
100 100
); );
Skeleton skeleton = new Skeleton( arena.add(skeleton);
"Knochensoldat", arena.add(iceGolem);
100
);
IceGolem iceGolem = new IceGolem( // Act
"Frostwächter", arena.attackAll(new FireSpell());
100
);
arena.add(player); // Assert
arena.add(skeleton); assertEquals(
arena.add(iceGolem); 75,
skeleton.getHitPoints()
);
// Act assertEquals(
arena.attackAll(new FireSpell()); 40,
iceGolem.getHitPoints()
// Assert );
assertAll(
() -> assertEquals(
70,
player.getHitPoints()
),
() -> assertEquals(
75,
skeleton.getHitPoints()
),
() -> assertEquals(
40,
iceGolem.getHitPoints()
)
);
}
@Test
@DisplayName(
"Lebende und besiegte Figuren werden getrennt"
)
void livingAndDefeatedCharactersAreSeparated() {
// Arrange
Arena<Character> arena = new Arena<>();
Player player = new Player(
"Held",
20
);
Skeleton skeleton = new Skeleton(
"Schwaches Skelett",
20
);
IceGolem iceGolem = new IceGolem(
"Frostwächter",
100
);
arena.add(player);
arena.add(skeleton);
arena.add(iceGolem);
// Act
arena.attackAll(new FireSpell());
List<Character> living =
arena.getLivingCharacters();
List<Character> defeated =
arena.getDefeatedCharacters();
// Assert
assertAll(
() -> assertEquals(
1,
living.size()
),
() -> assertTrue(
living.contains(iceGolem)
),
() -> assertEquals(
2,
defeated.size()
),
() -> assertTrue(
defeated.contains(player)
),
() -> assertTrue(
defeated.contains(skeleton)
)
);
}
@Test
@DisplayName(
"Besiegte Figuren können entfernt werden"
)
void defeatedCharactersCanBeRemoved() {
// Arrange
Arena<Character> arena = new Arena<>();
Player player = new Player(
"Held",
20
);
IceGolem iceGolem = new IceGolem(
"Frostwächter",
100
);
arena.add(player);
arena.add(iceGolem);
arena.attackAll(new FireSpell());
// Act
for (Character defeated
: arena.getDefeatedCharacters()) {
arena.remove(defeated);
}
// Assert
assertAll(
() -> assertEquals(
1,
arena.size()
),
() -> assertTrue(
arena.getCharacters()
.contains(iceGolem)
),
() -> assertFalse(
arena.getCharacters()
.contains(player)
)
);
}
} }
@Nested @Test
@DisplayName("Verwaltung der Arena") public void swordAttackAffectsEnemyTypesDifferently() {
class ArenaManagementTests { // Arrange
Arena<Enemy> arena = new Arena<>();
@Test Skeleton skeleton = new Skeleton(
@DisplayName( "Knochensoldat",
"remove entfernt eine vorhandene Figur" 100
) );
void removeDeletesCharacter() {
// Arrange
Arena<Player> arena = new Arena<>();
Player player = new Player( IceGolem iceGolem = new IceGolem(
"Held", "Frostwächter",
100 100
); );
arena.add(player); arena.add(skeleton);
arena.add(iceGolem);
// Act // Act
boolean removed = arena.attackAll(new SwordAttack());
arena.remove(player);
// Assert // Assert
assertAll( assertEquals(
() -> assertTrue(removed), 60,
() -> assertTrue( skeleton.getHitPoints()
arena.isEmpty() );
),
() -> assertEquals( assertEquals(
0, 85,
arena.size() iceGolem.getHitPoints()
) );
); }
@Test
public void mixedArenaAttacksAllCharacterTypes() {
// Arrange
Arena<Character> arena = new Arena<>();
Player player = new Player(
"Held",
100
);
Skeleton skeleton = new Skeleton(
"Knochensoldat",
100
);
IceGolem iceGolem = new IceGolem(
"Frostwächter",
100
);
arena.add(player);
arena.add(skeleton);
arena.add(iceGolem);
// Act
arena.attackAll(new FireSpell());
// Assert
assertEquals(
70,
player.getHitPoints()
);
assertEquals(
75,
skeleton.getHitPoints()
);
assertEquals(
40,
iceGolem.getHitPoints()
);
}
@Test
public void livingAndDefeatedCharactersAreSeparated() {
// Arrange
Arena<Character> arena = new Arena<>();
Player player = new Player(
"Held",
20
);
Skeleton skeleton = new Skeleton(
"Schwaches Skelett",
20
);
IceGolem iceGolem = new IceGolem(
"Frostwächter",
100
);
arena.add(player);
arena.add(skeleton);
arena.add(iceGolem);
// Act
arena.attackAll(new FireSpell());
List<Character> living =
arena.getLivingCharacters();
List<Character> defeated =
arena.getDefeatedCharacters();
// Assert
assertEquals(
1,
living.size()
);
assertTrue(
living.contains(iceGolem)
);
assertEquals(
2,
defeated.size()
);
assertTrue(
defeated.contains(player)
);
assertTrue(
defeated.contains(skeleton)
);
}
@Test
public void defeatedCharactersCanBeRemoved() {
// Arrange
Arena<Character> arena = new Arena<>();
Player player = new Player(
"Held",
20
);
IceGolem iceGolem = new IceGolem(
"Frostwächter",
100
);
arena.add(player);
arena.add(iceGolem);
arena.attackAll(new FireSpell());
// Act
for (Character defeated
: arena.getDefeatedCharacters()) {
arena.remove(defeated);
} }
@Test // Assert
@DisplayName( assertEquals(
"remove liefert false für eine unbekannte Figur" 1,
) arena.size()
void removingUnknownCharacterReturnsFalse() { );
// Arrange
Arena<Player> arena = new Arena<>();
Player storedPlayer = new Player( assertTrue(
"Held", arena.getCharacters()
100 .contains(iceGolem)
); );
Player unknownPlayer = new Player( assertFalse(
"Fremder", arena.getCharacters()
100 .contains(player)
); );
}
arena.add(storedPlayer); @Test
public void removeDeletesCharacter() {
// Arrange
Arena<Player> arena = new Arena<>();
// Act Player player = new Player(
boolean removed = "Held",
arena.remove(unknownPlayer); 100
);
// Assert arena.add(player);
assertAll(
() -> assertFalse(removed),
() -> assertEquals(
1,
arena.size()
)
);
}
@Test // Act
@DisplayName( boolean removed =
"getCharacters liefert ein unveränderliches Set" arena.remove(player);
)
void returnedCharacterSetIsUnmodifiable() {
// Arrange
Arena<Player> arena = new Arena<>();
arena.add( // Assert
new Player( assertTrue(removed);
"Held", assertTrue(arena.isEmpty());
100
)
);
Set<Player> characters = assertEquals(
arena.getCharacters(); 0,
arena.size()
);
}
// Act und Assert @Test
assertThrows( public void removingUnknownCharacterReturnsFalse() {
UnsupportedOperationException.class, // Arrange
characters::clear Arena<Player> arena = new Arena<>();
);
}
@Test Player storedPlayer = new Player(
@DisplayName( "Held",
"null kann nicht hinzugefügt werden" 100
) );
void nullCharacterCannotBeAdded() {
Arena<Character> arena = new Arena<>();
assertThrows( Player unknownPlayer = new Player(
NullPointerException.class, "Fremder",
() -> arena.add(null) 100
); );
}
@Test arena.add(storedPlayer);
@DisplayName(
"attackAll akzeptiert keinen null-Angriff"
)
void nullAttackIsRejected() {
Arena<Character> arena = new Arena<>();
assertThrows( // Act
NullPointerException.class, boolean removed =
() -> arena.attackAll(null) arena.remove(unknownPlayer);
);
} // Assert
assertFalse(removed);
assertEquals(
1,
arena.size()
);
}
@Test(expected = UnsupportedOperationException.class)
public void returnedCharacterSetIsUnmodifiable() {
Arena<Player> arena = new Arena<>();
arena.add(
new Player(
"Held",
100
)
);
arena.getCharacters().clear();
}
@Test(expected = NullPointerException.class)
public void nullCharacterCannotBeAdded() {
Arena<Character> arena = new Arena<>();
arena.add(null);
}
@Test(expected = NullPointerException.class)
public void nullAttackIsRejected() {
Arena<Character> arena = new Arena<>();
arena.attackAll(null);
} }
} }