diff --git a/src/ArenaTest.java b/src/ArenaTest.java
index 6962f0a..1454d02 100644
--- a/src/ArenaTest.java
+++ b/src/ArenaTest.java
@@ -1,445 +1,366 @@
-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 {
+public class ArenaTest {
 
-    @Nested
-    @DisplayName("Spieler-Arena")
-    class PlayerArenaTests {
+    @Test
+    public void attackAllAttacksEveryPlayer() {
+        // Arrange
+        Arena<Player> arena = new Arena<>();
 
-        @Test
-        @DisplayName(
-                "Ein Angriff wird auf alle Spieler angewendet"
-        )
-        void attackAllAttacksEveryPlayer() {
-            // Arrange
-            Arena<Player> arena = new Arena<>();
+        Player warrior = new Player(
+                "Krieger",
+                100
+        );
 
-            Player warrior = new Player(
-                    "Krieger",
-                    100
-            );
+        Player mage = new Player(
+                "Magier",
+                70
+        );
 
-            Player mage = new Player(
-                    "Magier",
-                    70
-            );
+        arena.add(warrior);
+        arena.add(mage);
 
-            arena.add(warrior);
-            arena.add(mage);
+        // Act
+        arena.attackAll(new SwordAttack());
 
-            // Act
-            arena.attackAll(new SwordAttack());
+        // Assert
+        assertEquals(
+                70,
+                warrior.getHitPoints()
+        );
 
-            // Assert
-            assertAll(
-                    () -> assertEquals(
-                            70,
-                            warrior.getHitPoints()
-                    ),
-                    () -> assertEquals(
-                            40,
-                            mage.getHitPoints()
-                    ),
-                    () -> assertFalse(
-                            warrior.isDefeated()
-                    ),
-                    () -> assertFalse(
-                            mage.isDefeated()
-                    )
-            );
-        }
+        assertEquals(
+                40,
+                mage.getHitPoints()
+        );
 
-        @Test
-        @DisplayName(
-                "Dasselbe Objekt wird im Set nicht doppelt gespeichert"
-        )
-        void samePlayerIsNotAddedTwice() {
-            // Arrange
-            Arena<Player> arena = new Arena<>();
+        assertFalse(
+                warrior.isDefeated()
+        );
 
-            Player player = new Player(
-                    "Held",
-                    100
-            );
-
-            // Act
-            arena.add(player);
-            arena.add(player);
-
-            // Assert
-            assertEquals(
-                    1,
-                    arena.size()
-            );
-        }
+        assertFalse(
+                mage.isDefeated()
+        );
     }
 
-    @Nested
-    @DisplayName("Gegner-Arena")
-    class EnemyArenaTests {
+    @Test
+    public void samePlayerIsNotAddedTwice() {
+        // Arrange
+        Arena<Player> arena = new Arena<>();
 
-        @Test
-        @DisplayName(
-                "Double Dispatch wirkt für jeden Gegnertyp unterschiedlich"
-        )
-        void fireSpellAffectsEnemyTypesDifferently() {
-            // Arrange
-            Arena<Enemy> arena = new Arena<>();
+        Player player = new Player(
+                "Held",
+                100
+        );
 
-            Skeleton skeleton = new Skeleton(
-                    "Knochensoldat",
-                    100
-            );
+        // Act
+        arena.add(player);
+        arena.add(player);
 
-            IceGolem iceGolem = new IceGolem(
-                    "Frostwächter",
-                    100
-            );
-
-            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()
-                    )
-            );
-        }
+        // Assert
+        assertEquals(
+                1,
+                arena.size()
+        );
     }
 
-    @Nested
-    @DisplayName("Gemischte Arena")
-    class MixedArenaTests {
+    @Test
+    public void fireSpellAffectsEnemyTypesDifferently() {
+        // Arrange
+        Arena<Enemy> arena = new Arena<>();
 
-        @Test
-        @DisplayName(
-                "Spieler und Gegner können gemeinsam angegriffen werden"
-        )
-        void mixedArenaAttacksAllCharacterTypes() {
-            // Arrange
-            Arena<Character> arena = new Arena<>();
+        Skeleton skeleton = new Skeleton(
+                "Knochensoldat",
+                100
+        );
 
-            Player player = new Player(
-                    "Held",
-                    100
-            );
+        IceGolem iceGolem = new IceGolem(
+                "Frostwächter",
+                100
+        );
 
-            Skeleton skeleton = new Skeleton(
-                    "Knochensoldat",
-                    100
-            );
+        arena.add(skeleton);
+        arena.add(iceGolem);
 
-            IceGolem iceGolem = new IceGolem(
-                    "Frostwächter",
-                    100
-            );
+        // Act
+        arena.attackAll(new FireSpell());
 
-            arena.add(player);
-            arena.add(skeleton);
-            arena.add(iceGolem);
+        // Assert
+        assertEquals(
+                75,
+                skeleton.getHitPoints()
+        );
 
-            // Act
-            arena.attackAll(new FireSpell());
-
-            // 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)
-                    )
-            );
-        }
+        assertEquals(
+                40,
+                iceGolem.getHitPoints()
+        );
     }
 
-    @Nested
-    @DisplayName("Verwaltung der Arena")
-    class ArenaManagementTests {
+    @Test
+    public void swordAttackAffectsEnemyTypesDifferently() {
+        // Arrange
+        Arena<Enemy> arena = new Arena<>();
 
-        @Test
-        @DisplayName(
-                "remove entfernt eine vorhandene Figur"
-        )
-        void removeDeletesCharacter() {
-            // Arrange
-            Arena<Player> arena = new Arena<>();
+        Skeleton skeleton = new Skeleton(
+                "Knochensoldat",
+                100
+        );
 
-            Player player = new Player(
-                    "Held",
-                    100
-            );
+        IceGolem iceGolem = new IceGolem(
+                "Frostwächter",
+                100
+        );
 
-            arena.add(player);
+        arena.add(skeleton);
+        arena.add(iceGolem);
 
-            // Act
-            boolean removed =
-                    arena.remove(player);
+        // Act
+        arena.attackAll(new SwordAttack());
 
-            // Assert
-            assertAll(
-                    () -> assertTrue(removed),
-                    () -> assertTrue(
-                            arena.isEmpty()
-                    ),
-                    () -> assertEquals(
-                            0,
-                            arena.size()
-                    )
-            );
+        // Assert
+        assertEquals(
+                60,
+                skeleton.getHitPoints()
+        );
+
+        assertEquals(
+                85,
+                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
-        @DisplayName(
-                "remove liefert false für eine unbekannte Figur"
-        )
-        void removingUnknownCharacterReturnsFalse() {
-            // Arrange
-            Arena<Player> arena = new Arena<>();
+        // Assert
+        assertEquals(
+                1,
+                arena.size()
+        );
 
-            Player storedPlayer = new Player(
-                    "Held",
-                    100
-            );
+        assertTrue(
+                arena.getCharacters()
+                        .contains(iceGolem)
+        );
 
-            Player unknownPlayer = new Player(
-                    "Fremder",
-                    100
-            );
+        assertFalse(
+                arena.getCharacters()
+                        .contains(player)
+        );
+    }
 
-            arena.add(storedPlayer);
+    @Test
+    public void removeDeletesCharacter() {
+        // Arrange
+        Arena<Player> arena = new Arena<>();
 
-            // Act
-            boolean removed =
-                    arena.remove(unknownPlayer);
+        Player player = new Player(
+                "Held",
+                100
+        );
 
-            // Assert
-            assertAll(
-                    () -> assertFalse(removed),
-                    () -> assertEquals(
-                            1,
-                            arena.size()
-                    )
-            );
-        }
+        arena.add(player);
 
-        @Test
-        @DisplayName(
-                "getCharacters liefert ein unveränderliches Set"
-        )
-        void returnedCharacterSetIsUnmodifiable() {
-            // Arrange
-            Arena<Player> arena = new Arena<>();
+        // Act
+        boolean removed =
+                arena.remove(player);
 
-            arena.add(
-                    new Player(
-                            "Held",
-                            100
-                    )
-            );
+        // Assert
+        assertTrue(removed);
+        assertTrue(arena.isEmpty());
 
-            Set<Player> characters =
-                    arena.getCharacters();
+        assertEquals(
+                0,
+                arena.size()
+        );
+    }
 
-            // Act und Assert
-            assertThrows(
-                    UnsupportedOperationException.class,
-                    characters::clear
-            );
-        }
+    @Test
+    public void removingUnknownCharacterReturnsFalse() {
+        // Arrange
+        Arena<Player> arena = new Arena<>();
 
-        @Test
-        @DisplayName(
-                "null kann nicht hinzugefügt werden"
-        )
-        void nullCharacterCannotBeAdded() {
-            Arena<Character> arena = new Arena<>();
+        Player storedPlayer = new Player(
+                "Held",
+                100
+        );
 
-            assertThrows(
-                    NullPointerException.class,
-                    () -> arena.add(null)
-            );
-        }
+        Player unknownPlayer = new Player(
+                "Fremder",
+                100
+        );
 
-        @Test
-        @DisplayName(
-                "attackAll akzeptiert keinen null-Angriff"
-        )
-        void nullAttackIsRejected() {
-            Arena<Character> arena = new Arena<>();
+        arena.add(storedPlayer);
 
-            assertThrows(
-                    NullPointerException.class,
-                    () -> arena.attackAll(null)
-            );
-        }
+        // Act
+        boolean removed =
+                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);
     }
 }
\ No newline at end of file