package tests;

import static org.junit.Assert.*;

import liste.*;

/**
 * Die Test-Klasse SubTest10.
 *
 * @author Rainer Helfrich
 * @version 03.10.2020
 */
public class SubTest10 {


    public static void test1Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.anhaengen(184);
        Tester.pruefeListenInhalt(dieListe, new int[]{184});

        dieListe.anhaengen(90);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 90});

        assertTrue("Fehler: Element 90 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(90));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{184});

        assertFalse("Fehler: Element 332 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(332));
        dieListe.anhaengen(911);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 911});

        dieListe.anhaengen(418);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 418});

        dieListe.anhaengen(522);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 418, 522});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 522});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 522});

        assertFalse("Fehler: Element 952 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(952));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{184});

        assertTrue("Fehler: Element 184 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(184));
        dieListe.einfuegenBei(1, 362);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 362});

        dieListe.anhaengen(108);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 362, 108});

        assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265));
        assertFalse("Fehler: Element 640 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(640));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 362});

        dieListe.anhaengen(308);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 362, 308});

        dieListe.einfuegenBei(1, 627);
        Tester.pruefeListenInhalt(dieListe, new int[]{184, 627, 362, 308});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(603);
        Tester.pruefeListenInhalt(dieListe, new int[]{603});

        assertTrue("Fehler: Element 603 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(603));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(90);
        Tester.pruefeListenInhalt(dieListe, new int[]{90});

        assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(182);
        Tester.pruefeListenInhalt(dieListe, new int[]{182});

        dieListe.einfuegenBei(1, 371);
        Tester.pruefeListenInhalt(dieListe, new int[]{182, 371});

        dieListe.einfuegenBei(2, 525);
        Tester.pruefeListenInhalt(dieListe, new int[]{182, 371, 525});

        dieListe.einfuegenBei(3, 380);
        Tester.pruefeListenInhalt(dieListe, new int[]{182, 371, 525, 380});

        assertFalse("Fehler: Element 810 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(810));
        assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{371, 525, 380});

        assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{525, 380});

        assertFalse("Fehler: Element 253 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(253));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{380});

        dieListe.einfuegenBei(0, 942);
        Tester.pruefeListenInhalt(dieListe, new int[]{942, 380});

        dieListe.anhaengen(848);
        Tester.pruefeListenInhalt(dieListe, new int[]{942, 380, 848});

        assertTrue("Fehler: Element 380 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(380));
        assertFalse("Fehler: Element 620 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(620));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{942, 848});

        dieListe.einfuegenBei(2, 914);
        Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 914});

        assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914));
        assertTrue("Fehler: Element 848 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(848));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{942, 848});

        assertTrue("Fehler: Element 848 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(848));
        dieListe.einfuegenBei(2, 311);
        Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 311});

        assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687));
        dieListe.anhaengen(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 311, 7});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 863);
        Tester.pruefeListenInhalt(dieListe, new int[]{863});

        dieListe.einfuegenBei(1, 206);
        Tester.pruefeListenInhalt(dieListe, new int[]{863, 206});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{863});

        dieListe.anhaengen(360);
        Tester.pruefeListenInhalt(dieListe, new int[]{863, 360});

        dieListe.einfuegenBei(0, 860);
        Tester.pruefeListenInhalt(dieListe, new int[]{860, 863, 360});

        assertTrue("Fehler: Element 863 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(863));
        assertTrue("Fehler: Element 863 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(863));
        assertFalse("Fehler: Element 433 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(433));
        dieListe.anhaengen(230);
        Tester.pruefeListenInhalt(dieListe, new int[]{860, 863, 360, 230});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(264);
        Tester.pruefeListenInhalt(dieListe, new int[]{264});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 820);
        Tester.pruefeListenInhalt(dieListe, new int[]{820});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 796);
        Tester.pruefeListenInhalt(dieListe, new int[]{796});

        dieListe.anhaengen(860);
        Tester.pruefeListenInhalt(dieListe, new int[]{796, 860});

        assertTrue("Fehler: Element 796 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(796));
        dieListe.einfuegenBei(1, 141);
        Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 860});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{796, 141});

        dieListe.einfuegenBei(2, 703);
        Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703});

        dieListe.anhaengen(376);
        Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703, 376});

        dieListe.einfuegenBei(2, 536);
        Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 536, 703, 376});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703, 376});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(587);
        Tester.pruefeListenInhalt(dieListe, new int[]{587});

        dieListe.einfuegenBei(1, 240);
        Tester.pruefeListenInhalt(dieListe, new int[]{587, 240});

        dieListe.einfuegenBei(0, 449);
        Tester.pruefeListenInhalt(dieListe, new int[]{449, 587, 240});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{587, 240});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{587});

// Alles löschen
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 826);
        Tester.pruefeListenInhalt(dieListe, new int[]{826});

        dieListe.einfuegenBei(1, 361);
        Tester.pruefeListenInhalt(dieListe, new int[]{826, 361});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{826});

        assertTrue("Fehler: Element 826 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(826));
        dieListe.anhaengen(100);
        Tester.pruefeListenInhalt(dieListe, new int[]{826, 100});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(23);
        Tester.pruefeListenInhalt(dieListe, new int[]{23});

// Alles löschen
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(296);
        Tester.pruefeListenInhalt(dieListe, new int[]{296});

        dieListe.anhaengen(822);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 822});

        dieListe.einfuegenBei(2, 149);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 822, 149});

        dieListe.anhaengen(934);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 822, 149, 934});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 934});

        dieListe.einfuegenBei(2, 281);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 281, 934});

        assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950));
        dieListe.anhaengen(750);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 281, 934, 750});

        dieListe.einfuegenBei(0, 594);
        Tester.pruefeListenInhalt(dieListe, new int[]{594, 296, 149, 281, 934, 750});

        dieListe.anhaengen(787);
        Tester.pruefeListenInhalt(dieListe, new int[]{594, 296, 149, 281, 934, 750, 787});

    }

    public static void test2Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.einfuegenBei(0, 794);
        Tester.pruefeListenInhalt(dieListe, new int[]{794});

        dieListe.einfuegenBei(0, 18);
        Tester.pruefeListenInhalt(dieListe, new int[]{18, 794});

        dieListe.einfuegenBei(1, 546);
        Tester.pruefeListenInhalt(dieListe, new int[]{18, 546, 794});

        assertTrue("Fehler: Element 546 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(546));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{18, 794});

        dieListe.anhaengen(984);
        Tester.pruefeListenInhalt(dieListe, new int[]{18, 794, 984});

        assertFalse("Fehler: Element 957 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(957));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{794, 984});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{794});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 572);
        Tester.pruefeListenInhalt(dieListe, new int[]{572});

        dieListe.einfuegenBei(1, 599);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599});

        dieListe.anhaengen(284);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284});

        assertFalse("Fehler: Element 817 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(817));
        assertTrue("Fehler: Element 284 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(284));
        dieListe.einfuegenBei(2, 78);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 78, 284});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284});

        dieListe.anhaengen(529);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284, 529});

        assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284});

        assertFalse("Fehler: Element 540 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(540));
        dieListe.einfuegenBei(1, 9);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 9, 599, 284});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284});

        dieListe.anhaengen(469);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284, 469});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 469});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 469});

        dieListe.anhaengen(39);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 39});

        dieListe.anhaengen(880);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 39, 880});

        assertTrue("Fehler: Element 39 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(39));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 880});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 880});

        dieListe.einfuegenBei(1, 264);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 880});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 264});

        assertFalse("Fehler: Element 225 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(225));
        assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335));
        assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264));
        dieListe.einfuegenBei(2, 686);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 686});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 264});

        dieListe.einfuegenBei(2, 884);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884});

        dieListe.anhaengen(721);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884, 721});

        assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884));
        dieListe.anhaengen(307);
        Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884, 721, 307});

        dieListe.einfuegenBei(0, 26);
        Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 264, 884, 721, 307});

        assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599));
        assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264));
        assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 264, 721, 307});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 721, 307});

        dieListe.einfuegenBei(1, 82);
        Tester.pruefeListenInhalt(dieListe, new int[]{26, 82, 599, 721, 307});

        dieListe.anhaengen(531);
        Tester.pruefeListenInhalt(dieListe, new int[]{26, 82, 599, 721, 307, 531});

        dieListe.einfuegenBei(1, 686);
        Tester.pruefeListenInhalt(dieListe, new int[]{26, 686, 82, 599, 721, 307, 531});

        assertTrue("Fehler: Element 307 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(307));
// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 407);
        Tester.pruefeListenInhalt(dieListe, new int[]{407});

        assertFalse("Fehler: Element 254 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(254));
        dieListe.anhaengen(25);
        Tester.pruefeListenInhalt(dieListe, new int[]{407, 25});

        dieListe.anhaengen(262);
        Tester.pruefeListenInhalt(dieListe, new int[]{407, 25, 262});

        assertFalse("Fehler: Element 521 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(521));
        dieListe.anhaengen(736);
        Tester.pruefeListenInhalt(dieListe, new int[]{407, 25, 262, 736});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{407, 262, 736});

        assertFalse("Fehler: Element 346 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(346));
        dieListe.einfuegenBei(1, 149);
        Tester.pruefeListenInhalt(dieListe, new int[]{407, 149, 262, 736});

        assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736});

        dieListe.anhaengen(502);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736, 502});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(372);
        Tester.pruefeListenInhalt(dieListe, new int[]{372});

        assertTrue("Fehler: Element 372 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(372));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

// Alles löschen
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(999);
        Tester.pruefeListenInhalt(dieListe, new int[]{999});

        dieListe.anhaengen(790);
        Tester.pruefeListenInhalt(dieListe, new int[]{999, 790});

        assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905));
        assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360));
        dieListe.einfuegenBei(0, 524);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 999, 790});

        assertFalse("Fehler: Element 387 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(387));
        dieListe.einfuegenBei(2, 13);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 999, 13, 790});

        assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 13, 790});

        dieListe.einfuegenBei(1, 309);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 309, 13, 790});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{309, 13, 790});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{13, 790});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{790});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(245);
        Tester.pruefeListenInhalt(dieListe, new int[]{245});

        dieListe.einfuegenBei(0, 517);
        Tester.pruefeListenInhalt(dieListe, new int[]{517, 245});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{245});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 907);
        Tester.pruefeListenInhalt(dieListe, new int[]{907});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(898);
        Tester.pruefeListenInhalt(dieListe, new int[]{898});

        assertTrue("Fehler: Element 898 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(898));
        dieListe.einfuegenBei(0, 296);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 898});

        assertFalse("Fehler: Element 677 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(677));
        assertFalse("Fehler: Element 621 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(621));
        dieListe.anhaengen(777);
        Tester.pruefeListenInhalt(dieListe, new int[]{296, 898, 777});

        assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208));
// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 140);
        Tester.pruefeListenInhalt(dieListe, new int[]{140});

    }

    public static void test3Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.anhaengen(62);
        Tester.pruefeListenInhalt(dieListe, new int[]{62});

        assertTrue("Fehler: Element 62 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(62));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 247);
        Tester.pruefeListenInhalt(dieListe, new int[]{247});

        assertFalse("Fehler: Element 494 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(494));
        dieListe.anhaengen(425);
        Tester.pruefeListenInhalt(dieListe, new int[]{247, 425});

        assertTrue("Fehler: Element 247 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(247));
        assertTrue("Fehler: Element 425 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(425));
        assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{247});

        dieListe.anhaengen(552);
        Tester.pruefeListenInhalt(dieListe, new int[]{247, 552});

        assertFalse("Fehler: Element 295 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(295));
        assertFalse("Fehler: Element 259 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(259));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{247});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 395);
        Tester.pruefeListenInhalt(dieListe, new int[]{395});

        dieListe.anhaengen(387);
        Tester.pruefeListenInhalt(dieListe, new int[]{395, 387});

        assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{395});

        dieListe.einfuegenBei(1, 403);
        Tester.pruefeListenInhalt(dieListe, new int[]{395, 403});

        assertTrue("Fehler: Element 403 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(403));
        assertTrue("Fehler: Element 403 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(403));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{395});

        dieListe.einfuegenBei(0, 223);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 395});

        dieListe.einfuegenBei(2, 830);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 395, 830});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830});

        assertFalse("Fehler: Element 504 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(504));
        dieListe.anhaengen(277);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277});

        assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277));
        assertTrue("Fehler: Element 830 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(830));
        dieListe.anhaengen(292);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292});

        dieListe.einfuegenBei(4, 653);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 653});

        dieListe.einfuegenBei(4, 458);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653});

        dieListe.anhaengen(839);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839});

        dieListe.anhaengen(100);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839, 100});

        dieListe.anhaengen(73);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839, 100, 73});

        assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73});

        dieListe.anhaengen(110);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110});

        dieListe.einfuegenBei(9, 116);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110, 116});

        dieListe.einfuegenBei(9, 332);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110, 332, 116});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(927);
        Tester.pruefeListenInhalt(dieListe, new int[]{927});

        dieListe.anhaengen(526);
        Tester.pruefeListenInhalt(dieListe, new int[]{927, 526});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{526});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(837);
        Tester.pruefeListenInhalt(dieListe, new int[]{837});

        assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311));
        dieListe.einfuegenBei(0, 135);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 837});

        dieListe.einfuegenBei(1, 472);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 837});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 472});

        dieListe.anhaengen(811);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811});

        assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750));
        dieListe.anhaengen(775);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775});

        dieListe.einfuegenBei(4, 895);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775, 895});

        dieListe.einfuegenBei(4, 408);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775, 408, 895});

        assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325));
// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(366);
        Tester.pruefeListenInhalt(dieListe, new int[]{366});

        dieListe.anhaengen(786);
        Tester.pruefeListenInhalt(dieListe, new int[]{366, 786});

        assertFalse("Fehler: Element 734 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(734));
        dieListe.anhaengen(598);
        Tester.pruefeListenInhalt(dieListe, new int[]{366, 786, 598});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{366, 598});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{598});

        dieListe.anhaengen(668);
        Tester.pruefeListenInhalt(dieListe, new int[]{598, 668});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{668});

        dieListe.einfuegenBei(1, 344);
        Tester.pruefeListenInhalt(dieListe, new int[]{668, 344});

        assertTrue("Fehler: Element 344 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(344));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{668});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(620);
        Tester.pruefeListenInhalt(dieListe, new int[]{620});

        assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157));
        dieListe.anhaengen(389);
        Tester.pruefeListenInhalt(dieListe, new int[]{620, 389});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{620});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 72);
        Tester.pruefeListenInhalt(dieListe, new int[]{72});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(152);
        Tester.pruefeListenInhalt(dieListe, new int[]{152});

        dieListe.einfuegenBei(0, 101);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 152});

        dieListe.anhaengen(753);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753});

        dieListe.anhaengen(695);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753, 695});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753});

        dieListe.anhaengen(121);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753, 121});

        dieListe.einfuegenBei(1, 220);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 121});

        dieListe.einfuegenBei(4, 47);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 47, 121});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 121});

        dieListe.einfuegenBei(4, 453);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121});

        assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875));
        dieListe.anhaengen(349);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121, 349});

        dieListe.anhaengen(634);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121, 349, 634});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 453, 121, 349, 634});

        assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161));
        assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759));
        dieListe.einfuegenBei(3, 820);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634});

        dieListe.anhaengen(515);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634, 515});

        dieListe.anhaengen(715);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634, 515, 715});

        dieListe.einfuegenBei(6, 378);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 378, 349, 634, 515, 715});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 453, 121, 378, 349, 634, 515, 715});

        dieListe.einfuegenBei(6, 73);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 453, 121, 378, 73, 349, 634, 515, 715});

        dieListe.einfuegenBei(3, 0);
        Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 0, 453, 121, 378, 73, 349, 634, 515, 715});

    }

    public static void test4Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.anhaengen(434);
        Tester.pruefeListenInhalt(dieListe, new int[]{434});

        dieListe.anhaengen(157);
        Tester.pruefeListenInhalt(dieListe, new int[]{434, 157});

        dieListe.anhaengen(387);
        Tester.pruefeListenInhalt(dieListe, new int[]{434, 157, 387});

        dieListe.anhaengen(306);
        Tester.pruefeListenInhalt(dieListe, new int[]{434, 157, 387, 306});

        assertTrue("Fehler: Element 387 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(387));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306});

        assertFalse("Fehler: Element 922 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(922));
        dieListe.anhaengen(625);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306, 625});

        dieListe.einfuegenBei(3, 751);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306, 751, 625});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 625});

        assertFalse("Fehler: Element 498 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(498));
        assertFalse("Fehler: Element 782 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(782));
        dieListe.anhaengen(438);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 625, 438});

        dieListe.einfuegenBei(3, 758);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 758, 625, 438});

        assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 758, 625});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 758, 625});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 625});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 758});

        dieListe.anhaengen(584);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 584});

        dieListe.anhaengen(616);
        Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 584, 616});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616});

        assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965));
        dieListe.einfuegenBei(3, 652);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652});

        assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157));
        assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644));
        assertFalse("Fehler: Element 301 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(301));
        dieListe.anhaengen(660);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660});

        dieListe.einfuegenBei(5, 880);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660, 880});

        assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407));
        dieListe.anhaengen(711);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660, 880, 711});

        dieListe.einfuegenBei(2, 176);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711});

        dieListe.anhaengen(803);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711, 803});

        assertTrue("Fehler: Element 660 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(660));
        assertFalse("Fehler: Element 573 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(573));
        dieListe.anhaengen(63);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711, 803, 63});

        dieListe.einfuegenBei(4, 525);
        Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 525, 652, 660, 880, 711, 803, 63});

        dieListe.einfuegenBei(0, 50);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 880, 711, 803, 63});

        assertTrue("Fehler: Element 711 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(711));
        dieListe.einfuegenBei(8, 695);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63});

        dieListe.anhaengen(605);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605});

        dieListe.anhaengen(983);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983});

        assertTrue("Fehler: Element 880 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(880));
        assertFalse("Fehler: Element 224 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(224));
        dieListe.einfuegenBei(0, 535);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983});

        assertFalse("Fehler: Element 14 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(14));
        assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996));
        dieListe.anhaengen(800);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983, 800});

        dieListe.anhaengen(699);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983, 800, 699});

        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 800, 699});

        assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699});

        dieListe.anhaengen(964);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964});

        assertFalse("Fehler: Element 632 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(632));
        dieListe.anhaengen(699);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964, 699});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964, 699});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 803, 63, 605, 800, 699, 964, 699});

        dieListe.einfuegenBei(12, 210);
        Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 803, 63, 605, 210, 800, 699, 964, 699});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 778);
        Tester.pruefeListenInhalt(dieListe, new int[]{778});

        dieListe.einfuegenBei(0, 91);
        Tester.pruefeListenInhalt(dieListe, new int[]{91, 778});

        assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778));
        assertTrue("Fehler: Element 91 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(91));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{91});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(987);
        Tester.pruefeListenInhalt(dieListe, new int[]{987});

        assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966));
        assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987));
        dieListe.anhaengen(955);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 955});

        assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842));
        assertFalse("Fehler: Element 556 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(556));
        assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955));
        assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987));
        assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955));
        assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955));
        dieListe.einfuegenBei(2, 337);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337});

        assertTrue("Fehler: Element 337 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(337));
        dieListe.einfuegenBei(3, 877);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337, 877});

        dieListe.einfuegenBei(4, 50);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337, 877, 50});

        dieListe.einfuegenBei(1, 987);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 337, 877, 50});

        assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 337, 50});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50});

        dieListe.anhaengen(666);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 666});

        assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50});

        assertFalse("Fehler: Element 925 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(925));
        dieListe.einfuegenBei(4, 788);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 788});

        dieListe.anhaengen(194);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 788, 194});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 194});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 50, 194});

        dieListe.einfuegenBei(4, 451);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 50, 194, 451});

        assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 50, 194, 451});

        dieListe.einfuegenBei(2, 260);
        Tester.pruefeListenInhalt(dieListe, new int[]{987, 50, 260, 194, 451});

        assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 260, 194, 451});

        dieListe.einfuegenBei(1, 248);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 248, 260, 194, 451});

        dieListe.einfuegenBei(1, 380);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 380, 248, 260, 194, 451});

        dieListe.anhaengen(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{50, 380, 248, 260, 194, 451, 13});

    }

    public static void test5Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.einfuegenBei(0, 948);
        Tester.pruefeListenInhalt(dieListe, new int[]{948});

        dieListe.einfuegenBei(1, 800);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 800});

        dieListe.einfuegenBei(0, 881);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 948, 800});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 800});

        assertTrue("Fehler: Element 881 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(881));
        dieListe.anhaengen(568);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 568});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 800});

        dieListe.einfuegenBei(2, 734);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 734});

        assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800));
        dieListe.anhaengen(166);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 734, 166});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 166});

        dieListe.anhaengen(974);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 166, 974});

        dieListe.einfuegenBei(1, 814);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 800, 166, 974});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 800, 166});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 166});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{881, 166});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{166});

        dieListe.einfuegenBei(1, 801);
        Tester.pruefeListenInhalt(dieListe, new int[]{166, 801});

        assertFalse("Fehler: Element 564 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(564));
        dieListe.einfuegenBei(1, 727);
        Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801});

        assertFalse("Fehler: Element 503 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(503));
        dieListe.anhaengen(623);
        Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801, 623});

        dieListe.anhaengen(58);
        Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801, 623, 58});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(453);
        Tester.pruefeListenInhalt(dieListe, new int[]{453});

        dieListe.einfuegenBei(0, 517);
        Tester.pruefeListenInhalt(dieListe, new int[]{517, 453});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 132);
        Tester.pruefeListenInhalt(dieListe, new int[]{132});

        dieListe.einfuegenBei(0, 623);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 132});

        assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623));
        dieListe.einfuegenBei(1, 387);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 132});

        dieListe.anhaengen(518);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 132, 518});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518});

        dieListe.anhaengen(359);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 359});

        dieListe.anhaengen(845);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 359, 845});

        dieListe.einfuegenBei(3, 177);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 177, 359, 845});

        assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477));
        dieListe.einfuegenBei(4, 191);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 177, 191, 359, 845});

        assertTrue("Fehler: Element 177 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(177));
        assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725));
        dieListe.einfuegenBei(0, 837);
        Tester.pruefeListenInhalt(dieListe, new int[]{837, 623, 387, 518, 177, 191, 359, 845});

        assertTrue("Fehler: Element 359 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(359));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{837, 623, 387, 518, 177, 359, 845});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(936);
        Tester.pruefeListenInhalt(dieListe, new int[]{936});

        dieListe.anhaengen(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 0});

        dieListe.einfuegenBei(2, 588);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 588});

        assertFalse("Fehler: Element 470 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(470));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 0});

        dieListe.anhaengen(87);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87});

        assertFalse("Fehler: Element 784 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(784));
        dieListe.anhaengen(872);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87, 872});

        assertFalse("Fehler: Element 955 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(955));
        dieListe.einfuegenBei(3, 964);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87, 964, 872});

        assertTrue("Fehler: Element 0 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(0));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872});

        dieListe.einfuegenBei(4, 516);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872, 516});

        dieListe.anhaengen(22);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872, 516, 22});

        dieListe.einfuegenBei(3, 649);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 649, 872, 516, 22});

        dieListe.anhaengen(93);
        Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 649, 872, 516, 22, 93});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(828);
        Tester.pruefeListenInhalt(dieListe, new int[]{828});

        dieListe.einfuegenBei(1, 113);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 113});

        assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485));
        assertFalse("Fehler: Element 227 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(227));
        dieListe.anhaengen(306);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 113, 306});

        dieListe.einfuegenBei(2, 27);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 113, 27, 306});

        assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 306});

        dieListe.anhaengen(28);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 306, 28});

        assertTrue("Fehler: Element 828 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(828));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28});

        dieListe.einfuegenBei(3, 511);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28, 511});

        assertTrue("Fehler: Element 28 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(28));
        dieListe.anhaengen(749);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28, 511, 749});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749});

        dieListe.anhaengen(603);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749, 603});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749});

        dieListe.einfuegenBei(2, 539);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749});

        dieListe.anhaengen(331);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331});

        dieListe.anhaengen(837);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837});

        dieListe.anhaengen(353);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837, 353});

        assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412));
        dieListe.anhaengen(456);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837, 353, 456});

        assertTrue("Fehler: Element 456 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(456));
        dieListe.einfuegenBei(0, 524);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 511, 749, 331, 837, 353, 456});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 837, 353, 456});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456});

        assertTrue("Fehler: Element 28 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(28));
        assertTrue("Fehler: Element 353 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(353));
        dieListe.anhaengen(707);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456, 707});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 331, 353, 456});

        assertTrue("Fehler: Element 524 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(524));
        assertTrue("Fehler: Element 353 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(353));
        dieListe.anhaengen(264);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 331, 353, 456, 264});

        dieListe.einfuegenBei(1, 119);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264});

        assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482));
        dieListe.anhaengen(127);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264, 127});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264});

    }

    public static void test6Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
// Alles löschen
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(154);
        Tester.pruefeListenInhalt(dieListe, new int[]{154});

        dieListe.einfuegenBei(0, 572);
        Tester.pruefeListenInhalt(dieListe, new int[]{572, 154});

        dieListe.einfuegenBei(0, 253);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154});

        assertTrue("Fehler: Element 253 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(253));
        dieListe.anhaengen(282);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 282});

        assertFalse("Fehler: Element 704 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(704));
        dieListe.einfuegenBei(3, 692);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692, 282});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692});

        assertFalse("Fehler: Element 862 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(862));
        assertTrue("Fehler: Element 253 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(253));
        assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154));
        dieListe.anhaengen(587);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692, 587});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 587});

        assertFalse("Fehler: Element 818 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(818));
        assertFalse("Fehler: Element 878 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(878));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 587});

        assertFalse("Fehler: Element 293 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(293));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{253, 587});

        assertFalse("Fehler: Element 527 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(527));
        assertTrue("Fehler: Element 587 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(587));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{587});

        dieListe.einfuegenBei(0, 528);
        Tester.pruefeListenInhalt(dieListe, new int[]{528, 587});

        assertFalse("Fehler: Element 634 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(634));
// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 175);
        Tester.pruefeListenInhalt(dieListe, new int[]{175});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 268);
        Tester.pruefeListenInhalt(dieListe, new int[]{268});

// Alles löschen
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(239);
        Tester.pruefeListenInhalt(dieListe, new int[]{239});

        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        dieListe.einfuegenBei(1, 705);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 705});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{239});

        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        dieListe.anhaengen(77);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 77});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{239});

        dieListe.anhaengen(461);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 461});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{239});

        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        dieListe.einfuegenBei(0, 396);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 239});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{396});

        dieListe.anhaengen(749);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 749});

        assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{396});

        assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396));
        dieListe.einfuegenBei(1, 220);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220});

        dieListe.anhaengen(969);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969});

        dieListe.anhaengen(739);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969, 739});

        dieListe.anhaengen(846);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969, 739, 846});

        dieListe.einfuegenBei(2, 784);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846});

        dieListe.anhaengen(696);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846, 696});

        dieListe.anhaengen(509);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846, 696, 509});

        assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 509});

        dieListe.anhaengen(44);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 509, 44});

        assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 44});

        assertFalse("Fehler: Element 881 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(881));
        dieListe.anhaengen(947);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 44, 947});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{396, 784, 739, 846, 696, 44, 947});

        dieListe.einfuegenBei(0, 287);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 396, 784, 739, 846, 696, 44, 947});

        dieListe.einfuegenBei(6, 982);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 396, 784, 739, 846, 696, 982, 44, 947});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 846, 696, 982, 44, 947});

        dieListe.einfuegenBei(3, 226);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 226, 846, 696, 982, 44, 947});

        dieListe.einfuegenBei(2, 980);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 696, 982, 44, 947});

        dieListe.anhaengen(390);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 696, 982, 44, 947, 390});

        dieListe.einfuegenBei(6, 850);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 696, 982, 44, 947, 390});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 696, 982, 44, 947});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 982, 44, 947});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 226, 846, 850, 982, 44, 947});

        assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 846, 850, 982, 44, 947});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947});

        dieListe.einfuegenBei(2, 467);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 467, 226, 850, 982, 44, 947});

        assertFalse("Fehler: Element 512 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(512));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947});

        dieListe.anhaengen(351);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947, 351});

        dieListe.einfuegenBei(2, 644);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 644, 226, 850, 982, 44, 947, 351});

        assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739));
        assertTrue("Fehler: Element 287 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(287));
        dieListe.einfuegenBei(1, 594);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 739, 644, 226, 850, 982, 44, 947, 351});

        dieListe.anhaengen(940);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 739, 644, 226, 850, 982, 44, 947, 351, 940});

        dieListe.einfuegenBei(2, 531);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940});

        dieListe.anhaengen(544);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544});

        assertFalse("Fehler: Element 35 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(35));
        dieListe.anhaengen(409);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544, 409});

        assertFalse("Fehler: Element 523 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(523));
        assertTrue("Fehler: Element 940 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(940));
        dieListe.einfuegenBei(13, 257);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544, 257, 409});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 947, 351, 940, 544, 257, 409});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 982, 947, 351, 940, 544, 257, 409});

        assertTrue("Fehler: Element 226 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(226));
        assertFalse("Fehler: Element 717 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(717));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 982, 947, 351, 940, 257, 409});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 947, 351, 940, 257, 409});

        assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739));
        dieListe.anhaengen(37);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 947, 351, 940, 257, 409, 37});

        dieListe.einfuegenBei(3, 28);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 28, 739, 644, 226, 947, 351, 940, 257, 409, 37});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 28, 739, 644, 947, 351, 940, 257, 409, 37});

    }

    public static void test7Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.anhaengen(547);
        Tester.pruefeListenInhalt(dieListe, new int[]{547});

        dieListe.einfuegenBei(1, 385);
        Tester.pruefeListenInhalt(dieListe, new int[]{547, 385});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{547});

        assertFalse("Fehler: Element 189 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(189));
        assertTrue("Fehler: Element 547 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(547));
        dieListe.einfuegenBei(1, 346);
        Tester.pruefeListenInhalt(dieListe, new int[]{547, 346});

        dieListe.anhaengen(142);
        Tester.pruefeListenInhalt(dieListe, new int[]{547, 346, 142});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{346, 142});

        assertTrue("Fehler: Element 346 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(346));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{142});

        dieListe.anhaengen(920);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 920});

        dieListe.anhaengen(857);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 857});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 920});

        dieListe.anhaengen(715);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715});

        dieListe.anhaengen(964);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715, 964});

        assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920));
        dieListe.anhaengen(516);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715, 964, 516});

        assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964));
        dieListe.einfuegenBei(1, 171);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 920, 715, 964, 516});

        dieListe.einfuegenBei(2, 48);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 48, 920, 715, 964, 516});

        dieListe.einfuegenBei(4, 256);
        Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 48, 920, 256, 715, 964, 516});

        dieListe.einfuegenBei(0, 239);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 964, 516});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 516});

        assertTrue("Fehler: Element 715 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(715));
        dieListe.anhaengen(725);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 516, 725});

        dieListe.einfuegenBei(1, 295);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516, 725});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516});

        dieListe.anhaengen(355);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516, 355});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 516, 355});

        assertFalse("Fehler: Element 930 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(930));
        assertFalse("Fehler: Element 934 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(934));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355});

        assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179));
        dieListe.anhaengen(412);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355, 412});

        dieListe.anhaengen(823);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355, 412, 823});

        dieListe.einfuegenBei(6, 150);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823});

        dieListe.anhaengen(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13});

        dieListe.anhaengen(484);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484});

        dieListe.anhaengen(493);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493});

        dieListe.anhaengen(74);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493, 74});

        assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171));
        assertTrue("Fehler: Element 150 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(150));
        dieListe.anhaengen(489);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489});

        dieListe.einfuegenBei(6, 238);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489});

        dieListe.anhaengen(417);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489, 417});

        assertFalse("Fehler: Element 456 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(456));
        dieListe.anhaengen(702);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489, 417, 702});

        assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171));
        dieListe.einfuegenBei(16, 947);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 417, 702});

        dieListe.entferneBei(18);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 702});

        dieListe.einfuegenBei(5, 573);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 702});

        dieListe.entferneBei(16);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 947, 489, 702});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 412, 823, 13, 484, 493, 947, 489, 702});

        dieListe.einfuegenBei(6, 794);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 794, 920, 238, 150, 256, 412, 823, 13, 484, 493, 947, 489, 702});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702});

        dieListe.anhaengen(420);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420});

        assertFalse("Fehler: Element 723 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(723));
        dieListe.anhaengen(207);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420, 207});

        assertTrue("Fehler: Element 207 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(207));
        assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179));
        dieListe.anhaengen(70);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420, 207, 70});

        assertTrue("Fehler: Element 412 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(412));
        dieListe.einfuegenBei(13, 373);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 373, 493, 947, 489, 702, 420, 207, 70});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 484, 373, 493, 947, 489, 702, 420, 207, 70});

        dieListe.einfuegenBei(11, 825);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70});

        dieListe.einfuegenBei(1, 170);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70});

        dieListe.anhaengen(450);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70, 450});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70, 450});

        dieListe.entferneBei(19);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450});

        dieListe.anhaengen(196);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196});

        dieListe.einfuegenBei(9, 574);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196});

        dieListe.einfuegenBei(5, 335);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196});

        dieListe.anhaengen(348);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348});

        dieListe.anhaengen(935);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935});

        assertTrue("Fehler: Element 420 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(420));
        assertTrue("Fehler: Element 295 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(295));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935});

        dieListe.anhaengen(441);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441});

        dieListe.einfuegenBei(2, 688);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441});

        assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489));
        dieListe.anhaengen(558);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558});

        dieListe.einfuegenBei(1, 613);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558});

        assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303));
        assertFalse("Fehler: Element 111 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(111));
        dieListe.anhaengen(369);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558, 369});

        dieListe.anhaengen(209);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558, 369, 209});

        dieListe.einfuegenBei(23, 243);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209});

        dieListe.einfuegenBei(19, 523);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 825, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209});

        dieListe.einfuegenBei(4, 144);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 144, 295, 171, 335, 920, 412, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209});

        assertFalse("Fehler: Element 121 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(121));
        assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489));
        dieListe.anhaengen(48);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209, 48});

        dieListe.einfuegenBei(16, 365);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 365, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209, 48});

    }

    public static void test8Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.einfuegenBei(0, 842);
        Tester.pruefeListenInhalt(dieListe, new int[]{842});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(767);
        Tester.pruefeListenInhalt(dieListe, new int[]{767});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 846);
        Tester.pruefeListenInhalt(dieListe, new int[]{846});

        dieListe.anhaengen(433);
        Tester.pruefeListenInhalt(dieListe, new int[]{846, 433});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{433});

        assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820));
        dieListe.anhaengen(466);
        Tester.pruefeListenInhalt(dieListe, new int[]{433, 466});

        dieListe.anhaengen(701);
        Tester.pruefeListenInhalt(dieListe, new int[]{433, 466, 701});

        dieListe.einfuegenBei(1, 40);
        Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701});

        dieListe.anhaengen(465);
        Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701, 465});

        dieListe.einfuegenBei(0, 121);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 433, 40, 466, 701, 465});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701, 465});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{433, 466, 701, 465});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465});

        dieListe.anhaengen(94);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94});

        dieListe.anhaengen(660);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660});

        assertFalse("Fehler: Element 31 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(31));
        dieListe.anhaengen(728);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660, 728});

        dieListe.anhaengen(683);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660, 728, 683});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 728, 683});

        dieListe.anhaengen(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 728, 683, 15});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 94, 728, 683, 15});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 15});

        dieListe.anhaengen(384);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 15, 384});

        assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155));
        assertTrue("Fehler: Element 683 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(683));
        assertTrue("Fehler: Element 728 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(728));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 384});

        dieListe.einfuegenBei(1, 182);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 182, 701, 728, 683, 384});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 384});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 683, 384});

        dieListe.anhaengen(211);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 683, 384, 211});

        dieListe.einfuegenBei(2, 916);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 916, 683, 384, 211});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211});

        dieListe.anhaengen(450);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211, 450});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{466, 683, 384, 211});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(916);
        Tester.pruefeListenInhalt(dieListe, new int[]{916});

        dieListe.anhaengen(598);
        Tester.pruefeListenInhalt(dieListe, new int[]{916, 598});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{598});

        assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598));
        assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112));
        assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598));
        dieListe.einfuegenBei(1, 161);
        Tester.pruefeListenInhalt(dieListe, new int[]{598, 161});

        assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598));
        dieListe.einfuegenBei(1, 483);
        Tester.pruefeListenInhalt(dieListe, new int[]{598, 483, 161});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{598, 483});

        assertTrue("Fehler: Element 483 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(483));
        dieListe.anhaengen(370);
        Tester.pruefeListenInhalt(dieListe, new int[]{598, 483, 370});

        assertFalse("Fehler: Element 266 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(266));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370});

        dieListe.anhaengen(497);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 497});

        assertTrue("Fehler: Element 497 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(497));
        dieListe.einfuegenBei(2, 273);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 273, 497});

        dieListe.einfuegenBei(2, 650);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497});

        dieListe.anhaengen(593);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497, 593});

        dieListe.einfuegenBei(6, 51);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497, 593, 51});

        dieListe.einfuegenBei(3, 175);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 497, 593, 51});

        dieListe.anhaengen(581);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 497, 593, 51, 581});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 593, 51, 581});

        assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 51, 581});

        dieListe.anhaengen(514);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 51, 581, 514});

        assertFalse("Fehler: Element 80 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(80));
        dieListe.einfuegenBei(3, 930);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 581, 514});

        dieListe.anhaengen(23);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 581, 514, 23});

        dieListe.einfuegenBei(7, 375);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23});

        dieListe.anhaengen(478);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23, 478});

        dieListe.anhaengen(793);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23, 478, 793});

        assertTrue("Fehler: Element 514 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(514));
        dieListe.einfuegenBei(9, 303);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 303, 514, 23, 478, 793});

        assertFalse("Fehler: Element 747 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(747));
        dieListe.einfuegenBei(11, 379);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 303, 514, 379, 23, 478, 793});

        assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 581, 303, 514, 379, 23, 478, 793});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793});

        dieListe.anhaengen(789);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789});

        dieListe.anhaengen(37);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789, 37});

        dieListe.anhaengen(727);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789, 37, 727});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 478, 793, 789, 37, 727});

        assertTrue("Fehler: Element 727 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(727));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 793, 789, 37, 727});

        dieListe.anhaengen(37);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 793, 789, 37, 727, 37});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 303, 514, 23, 793, 789, 37, 727, 37});

        dieListe.anhaengen(741);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 303, 514, 23, 793, 789, 37, 727, 37, 741});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(280);
        Tester.pruefeListenInhalt(dieListe, new int[]{280});

        dieListe.einfuegenBei(0, 744);
        Tester.pruefeListenInhalt(dieListe, new int[]{744, 280});

        dieListe.einfuegenBei(1, 382);
        Tester.pruefeListenInhalt(dieListe, new int[]{744, 382, 280});

        assertTrue("Fehler: Element 744 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(744));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{382, 280});

        assertTrue("Fehler: Element 280 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(280));
        dieListe.anhaengen(194);
        Tester.pruefeListenInhalt(dieListe, new int[]{382, 280, 194});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

// Alles löschen
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 932);
        Tester.pruefeListenInhalt(dieListe, new int[]{932});

        assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24));
    }

    public static void test9Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.einfuegenBei(0, 441);
        Tester.pruefeListenInhalt(dieListe, new int[]{441});

        dieListe.anhaengen(248);
        Tester.pruefeListenInhalt(dieListe, new int[]{441, 248});

        assertTrue("Fehler: Element 441 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(441));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{248});

        assertFalse("Fehler: Element 594 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(594));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(780);
        Tester.pruefeListenInhalt(dieListe, new int[]{780});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(676);
        Tester.pruefeListenInhalt(dieListe, new int[]{676});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(150);
        Tester.pruefeListenInhalt(dieListe, new int[]{150});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(932);
        Tester.pruefeListenInhalt(dieListe, new int[]{932});

        dieListe.anhaengen(942);
        Tester.pruefeListenInhalt(dieListe, new int[]{932, 942});

        dieListe.einfuegenBei(0, 162);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 932, 942});

        dieListe.einfuegenBei(3, 778);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 932, 942, 778});

        assertFalse("Fehler: Element 241 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(241));
        dieListe.einfuegenBei(1, 95);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778});

        dieListe.anhaengen(366);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366});

        assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76));
        dieListe.einfuegenBei(6, 134);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134});

        assertTrue("Fehler: Element 134 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(134));
        assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966));
        dieListe.einfuegenBei(7, 464);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134, 464});

        dieListe.anhaengen(910);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134, 464, 910});

        assertFalse("Fehler: Element 822 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(822));
        assertFalse("Fehler: Element 638 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(638));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 134, 464, 910});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 464, 910});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910});

        assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325));
        dieListe.anhaengen(755);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 755});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910});

        dieListe.einfuegenBei(6, 82);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82});

        assertTrue("Fehler: Element 910 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(910));
        dieListe.anhaengen(164);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82, 164});

        dieListe.anhaengen(916);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82, 164, 916});

        assertFalse("Fehler: Element 149 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(149));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916});

        dieListe.anhaengen(777);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916, 777});

        dieListe.anhaengen(618);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916, 777, 618});

        assertFalse("Fehler: Element 928 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(928));
        dieListe.einfuegenBei(6, 356);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 164, 916, 777, 618});

        dieListe.einfuegenBei(7, 239);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 239, 164, 916, 777, 618});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 239, 164, 916, 777});

        assertTrue("Fehler: Element 95 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(95));
        assertTrue("Fehler: Element 777 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(777));
        dieListe.einfuegenBei(7, 311);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 311, 239, 164, 916, 777});

        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        dieListe.anhaengen(774);
        Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 311, 239, 164, 916, 777, 774});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(787);
        Tester.pruefeListenInhalt(dieListe, new int[]{787});

        assertTrue("Fehler: Element 787 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(787));
        dieListe.anhaengen(732);
        Tester.pruefeListenInhalt(dieListe, new int[]{787, 732});

        dieListe.anhaengen(750);
        Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 750});

        dieListe.einfuegenBei(2, 158);
        Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 158, 750});

        dieListe.anhaengen(645);
        Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 158, 750, 645});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(196);
        Tester.pruefeListenInhalt(dieListe, new int[]{196});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(117);
        Tester.pruefeListenInhalt(dieListe, new int[]{117});

        dieListe.anhaengen(937);
        Tester.pruefeListenInhalt(dieListe, new int[]{117, 937});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{117});

// Alles löschen
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 485);
        Tester.pruefeListenInhalt(dieListe, new int[]{485});

        assertTrue("Fehler: Element 485 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(485));
        dieListe.einfuegenBei(0, 481);
        Tester.pruefeListenInhalt(dieListe, new int[]{481, 485});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{481});

        assertFalse("Fehler: Element 898 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(898));
        dieListe.einfuegenBei(1, 285);
        Tester.pruefeListenInhalt(dieListe, new int[]{481, 285});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{285});

        dieListe.anhaengen(133);
        Tester.pruefeListenInhalt(dieListe, new int[]{285, 133});

        dieListe.anhaengen(444);
        Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444});

        assertTrue("Fehler: Element 133 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(133));
        assertFalse("Fehler: Element 393 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(393));
        assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777));
        dieListe.einfuegenBei(3, 276);
        Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444, 276});

        dieListe.anhaengen(213);
        Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444, 276, 213});

        assertFalse("Fehler: Element 891 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(891));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 276, 213});

        assertFalse("Fehler: Element 764 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(764));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{285, 276, 213});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{276, 213});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{213});

// Alles löschen
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 251);
        Tester.pruefeListenInhalt(dieListe, new int[]{251});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 745);
        Tester.pruefeListenInhalt(dieListe, new int[]{745});

        assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745));
        assertFalse("Fehler: Element 233 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(233));
        assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745));
        dieListe.anhaengen(562);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 562});

        dieListe.anhaengen(447);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 447});

        dieListe.einfuegenBei(2, 274);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447});

        dieListe.anhaengen(620);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447, 620});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447});

        dieListe.einfuegenBei(2, 779);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 779, 274, 447});

        assertTrue("Fehler: Element 447 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(447));
        dieListe.einfuegenBei(2, 118);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 118, 779, 274, 447});

        assertFalse("Fehler: Element 494 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(494));
    }

    public static void test10Durchfuehren(Liste<Integer> dieListe) {
        assertTrue(dieListe.istLeer());
        dieListe.einfuegenBei(0, 903);
        Tester.pruefeListenInhalt(dieListe, new int[]{903});

// Alles löschen
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 665);
        Tester.pruefeListenInhalt(dieListe, new int[]{665});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(605);
        Tester.pruefeListenInhalt(dieListe, new int[]{605});

        dieListe.einfuegenBei(0, 446);
        Tester.pruefeListenInhalt(dieListe, new int[]{446, 605});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{605});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(900);
        Tester.pruefeListenInhalt(dieListe, new int[]{900});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 59);
        Tester.pruefeListenInhalt(dieListe, new int[]{59});

        assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59));
        dieListe.anhaengen(350);
        Tester.pruefeListenInhalt(dieListe, new int[]{59, 350});

        assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59));
        dieListe.anhaengen(180);
        Tester.pruefeListenInhalt(dieListe, new int[]{59, 350, 180});

        assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{59, 350});

        dieListe.anhaengen(853);
        Tester.pruefeListenInhalt(dieListe, new int[]{59, 350, 853});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 853});

        dieListe.anhaengen(311);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 311});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 853});

        dieListe.anhaengen(634);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 634});

        dieListe.einfuegenBei(2, 243);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 243, 634});

        dieListe.anhaengen(740);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 243, 634, 740});

        assertFalse("Fehler: Element 11 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(11));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 243, 634, 740});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740});

        assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634));
        assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634));
        dieListe.anhaengen(861);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740, 861});

        dieListe.anhaengen(828);
        Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740, 861, 828});

        assertFalse("Fehler: Element 837 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(837));
        assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714));
        dieListe.einfuegenBei(0, 664);
        Tester.pruefeListenInhalt(dieListe, new int[]{664, 350, 634, 740, 861, 828});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{664, 634, 740, 861, 828});

        assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 861, 828});

        dieListe.anhaengen(519);
        Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 861, 828, 519});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 828, 519});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{740, 828, 519});

        dieListe.einfuegenBei(0, 627);
        Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 828, 519});

        dieListe.einfuegenBei(2, 518);
        Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 518, 828, 519});

        assertTrue("Fehler: Element 519 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(519));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 518, 828});

        dieListe.einfuegenBei(0, 443);
        Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 740, 518, 828});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 518, 828});

        assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210));
        dieListe.einfuegenBei(2, 280);
        Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 280, 518, 828});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

// Alles löschen
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(425);
        Tester.pruefeListenInhalt(dieListe, new int[]{425});

        dieListe.einfuegenBei(1, 436);
        Tester.pruefeListenInhalt(dieListe, new int[]{425, 436});

        dieListe.anhaengen(637);
        Tester.pruefeListenInhalt(dieListe, new int[]{425, 436, 637});

        dieListe.einfuegenBei(0, 410);
        Tester.pruefeListenInhalt(dieListe, new int[]{410, 425, 436, 637});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{425, 436, 637});

        dieListe.einfuegenBei(1, 656);
        Tester.pruefeListenInhalt(dieListe, new int[]{425, 656, 436, 637});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.einfuegenBei(0, 61);
        Tester.pruefeListenInhalt(dieListe, new int[]{61});

// Alles löschen
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

// Alles löschen
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(502);
        Tester.pruefeListenInhalt(dieListe, new int[]{502});

        dieListe.einfuegenBei(1, 94);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 94});

        dieListe.einfuegenBei(0, 755);
        Tester.pruefeListenInhalt(dieListe, new int[]{755, 502, 94});

        dieListe.einfuegenBei(2, 542);
        Tester.pruefeListenInhalt(dieListe, new int[]{755, 502, 542, 94});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 542, 94});

        assertFalse("Fehler: Element 675 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(675));
        assertTrue("Fehler: Element 502 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(502));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 94});

        dieListe.anhaengen(869);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 94, 869});

        dieListe.einfuegenBei(1, 305);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 305, 94, 869});

        dieListe.anhaengen(970);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 305, 94, 869, 970});

        assertTrue("Fehler: Element 94 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(94));
        assertTrue("Fehler: Element 94 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(94));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{305, 94, 869, 970});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 970});

        assertTrue("Fehler: Element 970 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(970));
        dieListe.anhaengen(280);
        Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 970, 280});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 280});

        dieListe.anhaengen(498);
        Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 280, 498});

        dieListe.einfuegenBei(0, 967);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 94, 869, 280, 498});

        dieListe.einfuegenBei(1, 124);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 94, 869, 280, 498});

        dieListe.einfuegenBei(2, 761);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 761, 94, 869, 280, 498});

        dieListe.anhaengen(157);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 761, 94, 869, 280, 498, 157});

// Alles löschen
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        dieListe.entferneBei(0);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(105);
        Tester.pruefeListenInhalt(dieListe, new int[]{105});

        dieListe.anhaengen(59);
        Tester.pruefeListenInhalt(dieListe, new int[]{105, 59});

        assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{59});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{});

// Alles löschen
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

        dieListe.anhaengen(719);
        Tester.pruefeListenInhalt(dieListe, new int[]{719});

        dieListe.einfuegenBei(0, 427);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 719});

        dieListe.anhaengen(487);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 487});

        assertTrue("Fehler: Element 427 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(427));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 719});

        dieListe.einfuegenBei(1, 87);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 87, 719});

        dieListe.anhaengen(249);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 87, 719, 249});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 249});

        dieListe.anhaengen(215);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 249, 215});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{719, 249, 215});

    }
}
