chnaged test framework

src/ArenaTest.java

@@ -1,28 +1,15 @@
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 
 import java.util.List;
-import java.util.Set;
 
-import static org.junit.jupiter.api.Assertions.assertAll;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
-@DisplayName("Generische Arena")
-class ArenaTest {
-
-    @Nested
-    @DisplayName("Spieler-Arena")
-    class PlayerArenaTests {
+public class ArenaTest {
 
     @Test
-        @DisplayName(
-                "Ein Angriff wird auf alle Spieler angewendet"
-        )
-        void attackAllAttacksEveryPlayer() {
+    public void attackAllAttacksEveryPlayer() {
         // Arrange
         Arena<Player> arena = new Arena<>();
 
@@ -43,29 +30,27 @@ class ArenaTest {
         arena.attackAll(new SwordAttack());
 
         // Assert
-            assertAll(
-                    () -> assertEquals(
+        assertEquals(
                 70,
                 warrior.getHitPoints()
-                    ),
-                    () -> assertEquals(
+        );
+
+        assertEquals(
                 40,
                 mage.getHitPoints()
-                    ),
-                    () -> assertFalse(
+        );
+
+        assertFalse(
                 warrior.isDefeated()
-                    ),
-                    () -> assertFalse(
+        );
+
+        assertFalse(
                 mage.isDefeated()
-                    )
         );
     }
 
     @Test
-        @DisplayName(
-                "Dasselbe Objekt wird im Set nicht doppelt gespeichert"
-        )
-        void samePlayerIsNotAddedTwice() {
+    public void samePlayerIsNotAddedTwice() {
         // Arrange
         Arena<Player> arena = new Arena<>();
 
@@ -84,17 +69,9 @@ class ArenaTest {
                 arena.size()
         );
     }
-    }
-
-    @Nested
-    @DisplayName("Gegner-Arena")
-    class EnemyArenaTests {
 
     @Test
-        @DisplayName(
-                "Double Dispatch wirkt für jeden Gegnertyp unterschiedlich"
-        )
-        void fireSpellAffectsEnemyTypesDifferently() {
+    public void fireSpellAffectsEnemyTypesDifferently() {
         // Arrange
         Arena<Enemy> arena = new Arena<>();
 
@@ -115,23 +92,19 @@ class ArenaTest {
         arena.attackAll(new FireSpell());
 
         // Assert
-            assertAll(
-                    () -> assertEquals(
+        assertEquals(
                 75,
                 skeleton.getHitPoints()
-                    ),
-                    () -> assertEquals(
+        );
+
+        assertEquals(
                 40,
                 iceGolem.getHitPoints()
-                    )
         );
     }
 
     @Test
-        @DisplayName(
-                "Ein Schwert wirkt ebenfalls abhängig vom Gegnertyp"
-        )
-        void swordAttackAffectsEnemyTypesDifferently() {
+    public void swordAttackAffectsEnemyTypesDifferently() {
         // Arrange
         Arena<Enemy> arena = new Arena<>();
 
@@ -152,28 +125,19 @@ class ArenaTest {
         arena.attackAll(new SwordAttack());
 
         // Assert
-            assertAll(
-                    () -> assertEquals(
+        assertEquals(
                 60,
                 skeleton.getHitPoints()
-                    ),
-                    () -> assertEquals(
+        );
+
+        assertEquals(
                 85,
                 iceGolem.getHitPoints()
-                    )
         );
     }
-    }
-
-    @Nested
-    @DisplayName("Gemischte Arena")
-    class MixedArenaTests {
 
     @Test
-        @DisplayName(
-                "Spieler und Gegner können gemeinsam angegriffen werden"
-        )
-        void mixedArenaAttacksAllCharacterTypes() {
+    public void mixedArenaAttacksAllCharacterTypes() {
         // Arrange
         Arena<Character> arena = new Arena<>();
 
@@ -200,27 +164,24 @@ class ArenaTest {
         arena.attackAll(new FireSpell());
 
         // Assert
-            assertAll(
-                    () -> assertEquals(
+        assertEquals(
                 70,
                 player.getHitPoints()
-                    ),
-                    () -> assertEquals(
+        );
+
+        assertEquals(
                 75,
                 skeleton.getHitPoints()
-                    ),
-                    () -> assertEquals(
+        );
+
+        assertEquals(
                 40,
                 iceGolem.getHitPoints()
-                    )
         );
     }
 
     @Test
-        @DisplayName(
-                "Lebende und besiegte Figuren werden getrennt"
-        )
-        void livingAndDefeatedCharactersAreSeparated() {
+    public void livingAndDefeatedCharactersAreSeparated() {
         // Arrange
         Arena<Character> arena = new Arena<>();
 
@@ -253,32 +214,31 @@ class ArenaTest {
                 arena.getDefeatedCharacters();
 
         // Assert
-            assertAll(
-                    () -> assertEquals(
+        assertEquals(
                 1,
                 living.size()
-                    ),
-                    () -> assertTrue(
+        );
+
+        assertTrue(
                 living.contains(iceGolem)
-                    ),
-                    () -> assertEquals(
+        );
+
+        assertEquals(
                 2,
                 defeated.size()
-                    ),
-                    () -> assertTrue(
+        );
+
+        assertTrue(
                 defeated.contains(player)
-                    ),
-                    () -> assertTrue(
+        );
+
+        assertTrue(
                 defeated.contains(skeleton)
-                    )
         );
     }
 
     @Test
-        @DisplayName(
-                "Besiegte Figuren können entfernt werden"
-        )
-        void defeatedCharactersCanBeRemoved() {
+    public void defeatedCharactersCanBeRemoved() {
         // Arrange
         Arena<Character> arena = new Arena<>();
 
@@ -304,32 +264,24 @@ class ArenaTest {
         }
 
         // Assert
-            assertAll(
-                    () -> assertEquals(
+        assertEquals(
                 1,
                 arena.size()
-                    ),
-                    () -> assertTrue(
+        );
+
+        assertTrue(
                 arena.getCharacters()
                         .contains(iceGolem)
-                    ),
-                    () -> assertFalse(
+        );
+
+        assertFalse(
                 arena.getCharacters()
                         .contains(player)
-                    )
         );
     }
-    }
-
-    @Nested
-    @DisplayName("Verwaltung der Arena")
-    class ArenaManagementTests {
 
     @Test
-        @DisplayName(
-                "remove entfernt eine vorhandene Figur"
-        )
-        void removeDeletesCharacter() {
+    public void removeDeletesCharacter() {
         // Arrange
         Arena<Player> arena = new Arena<>();
 
@@ -345,23 +297,17 @@ class ArenaTest {
                 arena.remove(player);
 
         // Assert
-            assertAll(
-                    () -> assertTrue(removed),
-                    () -> assertTrue(
-                            arena.isEmpty()
-                    ),
-                    () -> assertEquals(
+        assertTrue(removed);
+        assertTrue(arena.isEmpty());
+
+        assertEquals(
                 0,
                 arena.size()
-                    )
         );
     }
 
     @Test
-        @DisplayName(
-                "remove liefert false für eine unbekannte Figur"
-        )
-        void removingUnknownCharacterReturnsFalse() {
+    public void removingUnknownCharacterReturnsFalse() {
         // Arrange
         Arena<Player> arena = new Arena<>();
 
@@ -382,21 +328,16 @@ class ArenaTest {
                 arena.remove(unknownPlayer);
 
         // Assert
-            assertAll(
-                    () -> assertFalse(removed),
-                    () -> assertEquals(
+        assertFalse(removed);
+
+        assertEquals(
                 1,
                 arena.size()
-                    )
         );
     }
 
-        @Test
-        @DisplayName(
-                "getCharacters liefert ein unveränderliches Set"
-        )
-        void returnedCharacterSetIsUnmodifiable() {
-            // Arrange
+    @Test(expected = UnsupportedOperationException.class)
+    public void returnedCharacterSetIsUnmodifiable() {
         Arena<Player> arena = new Arena<>();
 
         arena.add(
@@ -406,40 +347,20 @@ class ArenaTest {
                 )
         );
 
-            Set<Player> characters =
-                    arena.getCharacters();
-
-            // Act und Assert
-            assertThrows(
-                    UnsupportedOperationException.class,
-                    characters::clear
-            );
+        arena.getCharacters().clear();
     }
 
-        @Test
-        @DisplayName(
-                "null kann nicht hinzugefügt werden"
-        )
-        void nullCharacterCannotBeAdded() {
+    @Test(expected = NullPointerException.class)
+    public void nullCharacterCannotBeAdded() {
         Arena<Character> arena = new Arena<>();
 
-            assertThrows(
-                    NullPointerException.class,
-                    () -> arena.add(null)
-            );
+        arena.add(null);
     }
 
-        @Test
-        @DisplayName(
-                "attackAll akzeptiert keinen null-Angriff"
-        )
-        void nullAttackIsRejected() {
+    @Test(expected = NullPointerException.class)
+    public void nullAttackIsRejected() {
         Arena<Character> arena = new Arena<>();
 
-            assertThrows(
-                    NullPointerException.class,
-                    () -> arena.attackAll(null)
-            );
-        }
+        arena.attackAll(null);
     }
 }