package tests;

import static org.junit.Assert.*;

import liste.*;

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


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

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

        dieListe.anhaengen(896);
        Tester.pruefeListenInhalt(dieListe, new int[]{658, 801, 896});

        dieListe.einfuegenBei(0, 618);
        Tester.pruefeListenInhalt(dieListe, new int[]{618, 658, 801, 896});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{618, 658, 801});

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

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658});

        dieListe.anhaengen(888);
        Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658, 888});

        dieListe.einfuegenBei(0, 224);
        Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 658, 888});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 888});

        dieListe.einfuegenBei(3, 550);
        Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 550, 888});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 550});

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

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

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

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

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

        dieListe.anhaengen(939);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939});

        dieListe.anhaengen(967);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967});

        dieListe.anhaengen(40);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40});

        assertFalse("Fehler: Element 879 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(879));
        dieListe.einfuegenBei(6, 55);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40, 55});

        dieListe.anhaengen(80);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40, 55, 80});

        assertTrue("Fehler: Element 939 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(939));
        dieListe.einfuegenBei(4, 357);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 357, 967, 40, 55, 80});

        dieListe.anhaengen(245);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 357, 967, 40, 55, 80, 245});

        assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 55, 80, 245});

        dieListe.anhaengen(395);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 55, 80, 245, 395});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 80, 245, 395});

        dieListe.anhaengen(437);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 80, 245, 395, 437});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 437});

        dieListe.anhaengen(494);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 437, 494});

        assertFalse("Fehler: Element 762 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(762));
        dieListe.einfuegenBei(8, 282);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 282, 437, 494});

        assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40));
        assertFalse("Fehler: Element 855 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(855));
        assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 282, 437});

        assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395));
        dieListe.einfuegenBei(8, 123);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437});

        dieListe.anhaengen(82);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82});

        dieListe.anhaengen(437);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82, 437});

        dieListe.anhaengen(77);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82, 437, 77});

        assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77));
        dieListe.einfuegenBei(6, 155);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77});

        dieListe.anhaengen(570);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77, 570});

        assertFalse("Fehler: Element 456 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(456));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77, 570});

        assertFalse("Fehler: Element 379 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(379));
        assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40));
        dieListe.einfuegenBei(11, 585);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 82, 437, 77, 570});

        assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303));
        assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40));
        assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306));
        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 82, 437, 77});

        assertFalse("Fehler: Element 560 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(560));
        dieListe.einfuegenBei(12, 53);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77});

        dieListe.einfuegenBei(0, 512);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77});

        assertTrue("Fehler: Element 715 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(715));
        dieListe.einfuegenBei(1, 142);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 142, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77});

        dieListe.anhaengen(877);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877});

        dieListe.anhaengen(853);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853});

        assertTrue("Fehler: Element 437 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(437));
        dieListe.anhaengen(797);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853, 797});

        assertTrue("Fehler: Element 877 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(877));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853, 797});

        assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40));
        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797});

        dieListe.anhaengen(405);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405});

        dieListe.einfuegenBei(3, 454);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405});

        dieListe.anhaengen(642);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642});

        dieListe.anhaengen(438);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642, 438});

        dieListe.entferneBei(14);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 405, 642, 438});

        assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282));
        dieListe.entferneBei(17);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 405, 642});

        dieListe.einfuegenBei(15, 425);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642});

        assertFalse("Fehler: Element 61 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(61));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642});

        dieListe.einfuegenBei(15, 75);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642});

        dieListe.anhaengen(22);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22});

        dieListe.anhaengen(25);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22, 25});

        assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752));
        assertTrue("Fehler: Element 405 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(405));
        dieListe.anhaengen(591);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22, 25, 591});

        assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591});

        dieListe.einfuegenBei(0, 181);
        Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591});

        dieListe.anhaengen(145);
        Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145});

        dieListe.einfuegenBei(6, 117);
        Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 117, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145});

        dieListe.einfuegenBei(6, 495);
        Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 495, 117, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145});

        dieListe.einfuegenBei(15, 918);
        Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 495, 117, 437, 585, 53, 82, 877, 797, 425, 918, 405, 75, 642, 22, 25, 591, 145});

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

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

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

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

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

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

        dieListe.anhaengen(630);
        Tester.pruefeListenInhalt(dieListe, new int[]{783, 136, 630});

        assertTrue("Fehler: Element 783 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(783));
        dieListe.einfuegenBei(2, 107);
        Tester.pruefeListenInhalt(dieListe, new int[]{783, 136, 107, 630});

        assertFalse("Fehler: Element 697 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(697));
        dieListe.einfuegenBei(0, 986);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 783, 136, 107, 630});

        dieListe.anhaengen(441);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 783, 136, 107, 630, 441});

        dieListe.einfuegenBei(1, 403);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 136, 107, 630, 441});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 136, 107, 441});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 107, 441});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 107, 441});

        dieListe.anhaengen(758);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 107, 441, 758});

        assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986));
        dieListe.einfuegenBei(1, 70);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758});

        dieListe.anhaengen(19);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758, 19});

        dieListe.anhaengen(465);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758, 19, 465});

        dieListe.einfuegenBei(3, 602);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 602, 107, 441, 758, 19, 465});

        assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 602, 107, 441, 758, 465});

        assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758));
// 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.einfuegenBei(0, 623);
        Tester.pruefeListenInhalt(dieListe, new int[]{623});

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

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

        dieListe.einfuegenBei(3, 268);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 623, 146, 268});

        dieListe.einfuegenBei(1, 195);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 623, 146, 268});

        assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619));
        assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835));
        assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96));
        assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 146, 268});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 146});

        dieListe.einfuegenBei(2, 115);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 115, 146});

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

        dieListe.einfuegenBei(3, 850);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146, 850});

        assertFalse("Fehler: Element 944 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(944));
        dieListe.einfuegenBei(4, 532);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146, 850, 532});

        dieListe.einfuegenBei(1, 95);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532});

        dieListe.anhaengen(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532, 6});

        dieListe.anhaengen(631);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532, 6, 631});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 631});

        assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695));
        dieListe.anhaengen(257);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 631, 257});

        assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 257});

        assertFalse("Fehler: Element 833 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(833));
        assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146));
        dieListe.einfuegenBei(3, 655);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257});

        dieListe.anhaengen(358);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257, 358});

        assertFalse("Fehler: Element 249 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(249));
        dieListe.anhaengen(154);
        Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257, 358, 154});

// 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);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 198);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198});

        assertFalse("Fehler: Element 29 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(29));
        assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876));
        dieListe.einfuegenBei(1, 78);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 78, 26, 198});

        dieListe.anhaengen(925);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 78, 26, 198, 925});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 925});

        dieListe.anhaengen(568);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 925, 568});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 568});

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

        dieListe.einfuegenBei(3, 436);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568, 436});

        dieListe.anhaengen(137);
        Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568, 436, 137});

// 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.einfuegenBei(0, 623);
        Tester.pruefeListenInhalt(dieListe, new int[]{623});

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

        dieListe.einfuegenBei(1, 808);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731});

        dieListe.anhaengen(329);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731, 329});

        dieListe.anhaengen(33);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731, 329, 33});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33});

        assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617));
        assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623));
        dieListe.anhaengen(620);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620});

        dieListe.einfuegenBei(0, 425);
        Tester.pruefeListenInhalt(dieListe, new int[]{425, 623, 808, 329, 33, 620});

        dieListe.anhaengen(718);
        Tester.pruefeListenInhalt(dieListe, new int[]{425, 623, 808, 329, 33, 620, 718});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 718});

        dieListe.anhaengen(951);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 718, 951});

        dieListe.einfuegenBei(5, 928);
        Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 928, 718, 951});

        assertFalse("Fehler: Element 390 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(390));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{808, 329, 33, 620, 928, 718, 951});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 620, 928, 718, 951});

        dieListe.einfuegenBei(2, 897);
        Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 897, 620, 928, 718, 951});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 897, 620, 718, 951});

    }

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

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

        dieListe.anhaengen(63);
        Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63});

        assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265));
        dieListe.einfuegenBei(1, 736);
        Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63});

        dieListe.anhaengen(724);
        Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724});

        assertFalse("Fehler: Element 316 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(316));
        dieListe.einfuegenBei(5, 890);
        Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724, 890});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63, 724});

        assertTrue("Fehler: Element 724 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(724));
        assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93));
        dieListe.anhaengen(157);
        Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63, 724, 157});

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

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

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

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

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

        dieListe.einfuegenBei(2, 647);
        Tester.pruefeListenInhalt(dieListe, new int[]{63, 157, 647});

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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 290);
        Tester.pruefeListenInhalt(dieListe, new int[]{629, 5, 290});

        dieListe.einfuegenBei(1, 167);
        Tester.pruefeListenInhalt(dieListe, new int[]{629, 167, 5, 290});

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(445);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445});

        assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996));
        assertFalse("Fehler: Element 708 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(708));
        dieListe.anhaengen(328);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445, 328});

        dieListe.anhaengen(434);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445, 328, 434});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 434});

        dieListe.einfuegenBei(3, 183);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 434});

        assertTrue("Fehler: Element 434 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(434));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183});

        dieListe.einfuegenBei(2, 154);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 154, 328, 183});

        dieListe.einfuegenBei(1, 361);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 361, 797, 154, 328, 183});

        dieListe.anhaengen(171);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 361, 797, 154, 328, 183, 171});

        dieListe.einfuegenBei(1, 153);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 154, 328, 183, 171});

        assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966));
        assertTrue("Fehler: Element 967 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(967));
        dieListe.einfuegenBei(0, 842);
        Tester.pruefeListenInhalt(dieListe, new int[]{842, 967, 153, 361, 797, 154, 328, 183, 171});

        assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154));
        dieListe.anhaengen(86);
        Tester.pruefeListenInhalt(dieListe, new int[]{842, 967, 153, 361, 797, 154, 328, 183, 171, 86});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 154, 328, 183, 171, 86});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 86});

        dieListe.anhaengen(745);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 86, 745});

        assertFalse("Fehler: Element 283 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(283));
        dieListe.einfuegenBei(7, 945);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 945, 86, 745});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 797, 328, 183, 171, 945, 86, 745});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 171, 945, 86, 745});

        assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171));
        assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171));
        assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171));
        assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772));
        assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745));
        dieListe.einfuegenBei(5, 926);
        Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 171, 926, 945, 86, 745});

        dieListe.einfuegenBei(0, 374);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 797, 328, 183, 171, 926, 945, 86, 745});

        dieListe.einfuegenBei(7, 68);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 797, 328, 183, 171, 926, 68, 945, 86, 745});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 328, 183, 171, 926, 68, 945, 86, 745});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 183, 171, 926, 68, 945, 86, 745});

        assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695));
        assertTrue("Fehler: Element 86 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(86));
        assertFalse("Fehler: Element 378 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(378));
        dieListe.anhaengen(71);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 183, 171, 926, 68, 945, 86, 745, 71});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 86, 745, 71});

        dieListe.anhaengen(615);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 86, 745, 71, 615});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 745, 71, 615});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 945, 745, 71, 615});

        dieListe.einfuegenBei(2, 529);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615});

        assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617));
        assertTrue("Fehler: Element 926 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(926));
        dieListe.anhaengen(335);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335});

        assertTrue("Fehler: Element 945 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(945));
        dieListe.anhaengen(857);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857});

        dieListe.anhaengen(784);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784});

        dieListe.anhaengen(248);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784, 248});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784});

        assertTrue("Fehler: Element 857 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(857));
        dieListe.anhaengen(717);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784, 717});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 784, 717});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{374, 529, 171, 926, 945, 745, 71, 615, 335, 784, 717});

    }

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

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

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

        dieListe.einfuegenBei(0, 424);
        Tester.pruefeListenInhalt(dieListe, new int[]{424, 85, 263, 481});

        dieListe.einfuegenBei(0, 565);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 85, 263, 481});

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

        dieListe.einfuegenBei(4, 272);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481, 272});

        dieListe.anhaengen(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481, 272, 3});

        dieListe.einfuegenBei(3, 803);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 803, 481, 272, 3});

        dieListe.einfuegenBei(2, 980);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 263, 803, 481, 272, 3});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 803, 481, 272, 3});

        dieListe.anhaengen(658);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 803, 481, 272, 3, 658});

        dieListe.einfuegenBei(0, 893);
        Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 980, 803, 481, 272, 3, 658});

        dieListe.anhaengen(572);
        Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 980, 803, 481, 272, 3, 658, 572});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 803, 481, 272, 3, 658, 572});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 803, 481, 272, 3, 658, 572});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 803, 481, 272, 3, 658});

// 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(388);
        Tester.pruefeListenInhalt(dieListe, new int[]{388});

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

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

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

        assertFalse("Fehler: Element 524 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(524));
        dieListe.anhaengen(19);
        Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19});

        dieListe.anhaengen(458);
        Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19, 458});

        dieListe.anhaengen(379);
        Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19, 458, 379});

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

        assertTrue("Fehler: Element 935 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(935));
        dieListe.einfuegenBei(0, 127);
        Tester.pruefeListenInhalt(dieListe, new int[]{127, 935, 19, 458, 379});

        assertTrue("Fehler: Element 935 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(935));
// 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.einfuegenBei(0, 828);
        Tester.pruefeListenInhalt(dieListe, new int[]{828});

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

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

        dieListe.einfuegenBei(2, 333);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 333, 863});

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

        dieListe.anhaengen(266);
        Tester.pruefeListenInhalt(dieListe, new int[]{203, 828, 714, 333, 863, 266});

        assertTrue("Fehler: Element 203 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(203));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 333, 863, 266});

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

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 333, 266});

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303));
        dieListe.einfuegenBei(1, 723);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810});

        assertFalse("Fehler: Element 727 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(727));
        dieListe.anhaengen(693);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693});

        dieListe.anhaengen(340);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693, 340});

        dieListe.anhaengen(86);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693, 340, 86});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 86});

        dieListe.anhaengen(796);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 86, 796});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 796});

        assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340));
        dieListe.einfuegenBei(5, 218);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 796, 218});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 218});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 340, 218});

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

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

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{395, 24, 218});

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

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

        dieListe.einfuegenBei(4, 798);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 279, 395, 24, 798, 218});

        assertFalse("Fehler: Element 836 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(836));
        dieListe.einfuegenBei(0, 85);
        Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 279, 395, 24, 798, 218});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798, 218});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798});

        dieListe.anhaengen(217);
        Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798, 217});

        assertFalse("Fehler: Element 597 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(597));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 217});

        assertTrue("Fehler: Element 85 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(85));
        assertFalse("Fehler: Element 16 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(16));
        dieListe.einfuegenBei(3, 553);
        Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 553, 24, 217});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 553, 24, 217});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217});

        dieListe.anhaengen(429);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429});

        dieListe.anhaengen(956);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956});

        dieListe.anhaengen(334);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956, 334});

        assertTrue("Fehler: Element 334 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(334));
        dieListe.anhaengen(461);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956, 334, 461});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 334, 461});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461});

        dieListe.anhaengen(635);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461, 635});

        dieListe.anhaengen(718);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461, 635, 718});

        assertTrue("Fehler: Element 461 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(461));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 334, 461, 635, 718});

        dieListe.anhaengen(651);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 334, 461, 635, 718, 651});

        dieListe.einfuegenBei(1, 482);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 651});

        dieListe.anhaengen(108);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 651, 108});

        dieListe.einfuegenBei(8, 568);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 568, 651, 108});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 718, 568, 651, 108});

        dieListe.anhaengen(563);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 718, 568, 651, 108, 563});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 568, 651, 108, 563});

    }

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

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

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

        dieListe.einfuegenBei(2, 78);
        Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 78, 262});

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

        assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262));
        dieListe.anhaengen(340);
        Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262, 340});

        dieListe.einfuegenBei(5, 648);
        Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262, 648, 340});

        dieListe.einfuegenBei(3, 421);
        Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 78, 262, 648, 340});

        dieListe.einfuegenBei(4, 829);
        Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 829, 78, 262, 648, 340});

        dieListe.einfuegenBei(5, 757);
        Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 829, 757, 78, 262, 648, 340});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 421, 829, 757, 78, 262, 648, 340});

        assertTrue("Fehler: Element 829 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(829));
        dieListe.anhaengen(870);
        Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 421, 829, 757, 78, 262, 648, 340, 870});

        dieListe.einfuegenBei(0, 720);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 262, 648, 340, 870});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870});

        dieListe.einfuegenBei(10, 995);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995});

        dieListe.anhaengen(736);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736});

        assertTrue("Fehler: Element 648 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(648));
        dieListe.anhaengen(119);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119});

        assertTrue("Fehler: Element 41 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(41));
        dieListe.anhaengen(291);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 291});

        assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394));
        dieListe.anhaengen(196);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 291, 196});

        assertTrue("Fehler: Element 119 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(119));
        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 196});

        dieListe.anhaengen(135);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 196, 135});

        dieListe.einfuegenBei(7, 712);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135});

        dieListe.einfuegenBei(12, 137);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 137, 736, 119, 196, 135});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135});

        dieListe.einfuegenBei(4, 867);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 421, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135});

        dieListe.anhaengen(335);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135, 335});

        dieListe.einfuegenBei(5, 757);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135, 335});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 757, 78, 712, 648, 870, 995, 736, 119, 196, 135, 335});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 870, 995, 736, 119, 196, 135, 335});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 870, 995, 736, 119, 135, 335});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335});

        dieListe.einfuegenBei(13, 42);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42});

        dieListe.anhaengen(461);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42, 461});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42, 461});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461});

        assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135));
        dieListe.anhaengen(408);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408});

        dieListe.einfuegenBei(3, 984);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 736, 119, 135, 335, 42, 461, 408});

        assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449));
        assertTrue("Fehler: Element 984 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(984));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 135, 335, 42, 461, 408});

        assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239));
        dieListe.einfuegenBei(7, 790);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 790, 135, 335, 42, 461, 408});

        assertFalse("Fehler: Element 131 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(131));
        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 790, 135, 335, 42, 461});

// 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);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 535);
        Tester.pruefeListenInhalt(dieListe, new int[]{510, 146, 535});

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(539);
        Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539});

        dieListe.einfuegenBei(0, 638);
        Tester.pruefeListenInhalt(dieListe, new int[]{638, 754, 702, 539});

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

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

        dieListe.einfuegenBei(3, 911);
        Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 911, 411});

        dieListe.einfuegenBei(5, 138);
        Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 911, 411, 138});

        dieListe.einfuegenBei(1, 485);
        Tester.pruefeListenInhalt(dieListe, new int[]{754, 485, 702, 539, 911, 411, 138});

// 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(869);
        Tester.pruefeListenInhalt(dieListe, new int[]{869});

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

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

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140));
        dieListe.anhaengen(383);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 397, 315, 383});

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

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

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

        assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24));
        dieListe.einfuegenBei(2, 840);
        Tester.pruefeListenInhalt(dieListe, new int[]{429, 324, 840});

        dieListe.einfuegenBei(0, 173);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840});

        assertTrue("Fehler: Element 840 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(840));
        assertFalse("Fehler: Element 984 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(984));
        assertFalse("Fehler: Element 641 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(641));
        assertTrue("Fehler: Element 324 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(324));
        dieListe.einfuegenBei(4, 457);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840, 457});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840});

        dieListe.einfuegenBei(4, 95);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840, 95});

        assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95});

        assertFalse("Fehler: Element 669 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(669));
        dieListe.anhaengen(708);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95, 708});

        dieListe.einfuegenBei(4, 707);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95, 707, 708});

        dieListe.einfuegenBei(3, 33);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95, 707, 708});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95, 708});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95});

        dieListe.einfuegenBei(2, 128);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 128, 840, 33, 95});

        dieListe.einfuegenBei(1, 920);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 429, 128, 840, 33, 95});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95});

        dieListe.anhaengen(154);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95, 154});

        dieListe.anhaengen(640);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95, 154, 640});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 154, 640});

        assertTrue("Fehler: Element 128 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(128));
        assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920));
        assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920));
        dieListe.anhaengen(738);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 154, 640, 738});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738});

        dieListe.einfuegenBei(7, 637);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637});

        dieListe.einfuegenBei(8, 532);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637, 532});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637});

        assertFalse("Fehler: Element 511 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(511));
        dieListe.einfuegenBei(7, 742);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 742, 637});

        dieListe.einfuegenBei(4, 500);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637});

        dieListe.anhaengen(392);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637, 392});

        dieListe.anhaengen(550);
        Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637, 392, 550});

        assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847));
// 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);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

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

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

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

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

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

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

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

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

        dieListe.anhaengen(446);
        Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 446});

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

        dieListe.einfuegenBei(3, 271);
        Tester.pruefeListenInhalt(dieListe, new int[]{349, 426, 149, 271, 446});

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

        dieListe.einfuegenBei(0, 838);
        Tester.pruefeListenInhalt(dieListe, new int[]{838, 426, 149, 271, 446});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{838, 149, 271, 446});

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

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

        dieListe.einfuegenBei(1, 496);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 271});

        dieListe.einfuegenBei(2, 921);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 271});

        dieListe.einfuegenBei(1, 488);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 488, 496, 921, 271});

        dieListe.anhaengen(871);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 488, 496, 921, 271, 871});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 271, 871});

        assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871));
        assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 871});

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

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

        dieListe.einfuegenBei(0, 588);
        Tester.pruefeListenInhalt(dieListe, new int[]{588, 149, 921, 871, 105});

        dieListe.einfuegenBei(0, 733);
        Tester.pruefeListenInhalt(dieListe, new int[]{733, 588, 149, 921, 871, 105});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{588, 149, 921, 871, 105});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{588, 921, 871, 105});

        dieListe.einfuegenBei(0, 971);
        Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 921, 871, 105});

        dieListe.einfuegenBei(2, 738);
        Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 738, 921, 871, 105});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 921, 871, 105});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{971, 921, 871, 105});

        dieListe.einfuegenBei(0, 959);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 921, 871, 105});

        assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921));
        assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 105});

        dieListe.einfuegenBei(3, 313);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 313, 105});

        dieListe.einfuegenBei(3, 611);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 105});

        dieListe.einfuegenBei(5, 970);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 970, 105});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 105});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313});

        dieListe.anhaengen(628);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 628});

        dieListe.einfuegenBei(0, 214);
        Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313, 628});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313});

        dieListe.anhaengen(860);
        Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313, 860});

        assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 860});

        dieListe.einfuegenBei(3, 508);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 508, 611, 313, 860});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 508, 611, 313, 860});

        dieListe.anhaengen(446);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 508, 611, 313, 860, 446});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 860, 446});

        dieListe.einfuegenBei(6, 546);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 860, 446, 546});

        dieListe.einfuegenBei(4, 44);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546});

        assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871));
        dieListe.anhaengen(120);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546, 120});

        dieListe.anhaengen(43);
        Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546, 120, 43});

    }

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(329);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329});

        dieListe.anhaengen(65);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329, 65});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329});

        dieListe.einfuegenBei(2, 218);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 218, 329});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329});

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 245);
        Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 105});

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

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

        assertFalse("Fehler: Element 130 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(130));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 950, 161});

        dieListe.einfuegenBei(1, 562);
        Tester.pruefeListenInhalt(dieListe, new int[]{16, 562, 245, 950, 161});

        dieListe.einfuegenBei(0, 352);
        Tester.pruefeListenInhalt(dieListe, new int[]{352, 16, 562, 245, 950, 161});

        assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16));
        assertFalse("Fehler: Element 466 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(466));
        assertTrue("Fehler: Element 245 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(245));
// 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.einfuegenBei(0, 77);
        Tester.pruefeListenInhalt(dieListe, new int[]{77});

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

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

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

        dieListe.einfuegenBei(2, 398);
        Tester.pruefeListenInhalt(dieListe, new int[]{77, 806, 398});

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

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

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

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

        assertFalse("Fehler: Element 446 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(446));
        dieListe.anhaengen(297);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 297});

        assertTrue("Fehler: Element 806 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(806));
        assertFalse("Fehler: Element 328 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(328));
        dieListe.anhaengen(171);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 297, 171});

        dieListe.einfuegenBei(0, 39);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 285, 297, 171});

        dieListe.einfuegenBei(3, 77);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 285, 297, 171});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171});

        dieListe.anhaengen(675);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675});

        assertFalse("Fehler: Element 301 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(301));
        dieListe.anhaengen(871);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 871});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675});

        dieListe.anhaengen(474);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474});

        dieListe.anhaengen(351);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351});

        dieListe.einfuegenBei(9, 773);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351, 773});

        dieListe.anhaengen(780);
        Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351, 773, 780});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 77, 297, 171, 675, 474, 351, 773, 780});

        dieListe.einfuegenBei(2, 353);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780});

        dieListe.anhaengen(152);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780, 152});

        assertFalse("Fehler: Element 824 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(824));
        dieListe.einfuegenBei(1, 133);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780, 152});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 152});

        dieListe.einfuegenBei(11, 82);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152});

        dieListe.anhaengen(879);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152, 879});

        dieListe.anhaengen(526);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152, 879, 526});

        dieListe.einfuegenBei(6, 174);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526});

        dieListe.anhaengen(586);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526, 586});

        dieListe.anhaengen(919);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526, 586, 919});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 773, 780, 82, 152, 879, 526, 586, 919});

// 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.anhaengen(602);
        Tester.pruefeListenInhalt(dieListe, new int[]{602});

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68));
        dieListe.anhaengen(80);
        Tester.pruefeListenInhalt(dieListe, new int[]{483, 440, 512, 80});

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

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

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

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

    }

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212));
        assertFalse("Fehler: Element 722 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(722));
        assertTrue("Fehler: Element 539 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(539));
        assertTrue("Fehler: Element 499 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(499));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{499, 263});

        dieListe.anhaengen(368);
        Tester.pruefeListenInhalt(dieListe, new int[]{499, 263, 368});

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

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

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

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

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

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

        dieListe.anhaengen(562);
        Tester.pruefeListenInhalt(dieListe, new int[]{506, 686, 998, 562});

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

        dieListe.anhaengen(57);
        Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 562, 57});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 57});

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

        dieListe.anhaengen(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 7});

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

        dieListe.anhaengen(994);
        Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 994});

        dieListe.anhaengen(699);
        Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 994, 699});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 699});

        dieListe.anhaengen(653);
        Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 699, 653});

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

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

        assertFalse("Fehler: Element 740 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(740));
        dieListe.einfuegenBei(0, 307);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653});

        dieListe.einfuegenBei(3, 633);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633});

        dieListe.anhaengen(163);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633, 163});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633});

        dieListe.einfuegenBei(3, 695);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 695, 633});

        assertTrue("Fehler: Element 653 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(653));
        assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358));
        dieListe.einfuegenBei(2, 985);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633});

        dieListe.anhaengen(243);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243});

        dieListe.anhaengen(912);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243, 912});

        dieListe.anhaengen(923);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243, 912, 923});

        dieListe.einfuegenBei(2, 527);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 653, 695, 633, 243, 912, 923});

        dieListe.anhaengen(305);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 653, 695, 633, 243, 912, 923, 305});

        dieListe.einfuegenBei(4, 364);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 364, 653, 695, 633, 243, 912, 923, 305});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305});

        dieListe.anhaengen(110);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305, 110});

        dieListe.anhaengen(896);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305, 110, 896});

        dieListe.einfuegenBei(8, 554);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896});

        assertTrue("Fehler: Element 110 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(110));
        dieListe.anhaengen(615);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896, 615});

        dieListe.einfuegenBei(14, 220);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896, 220, 615});

        dieListe.einfuegenBei(9, 537);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615});

        dieListe.anhaengen(360);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360});

        dieListe.einfuegenBei(18, 447);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360, 447});

        dieListe.anhaengen(326);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360, 447, 326});

        assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360));
        dieListe.einfuegenBei(17, 17);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 17, 360, 447, 326});

        assertTrue("Fehler: Element 985 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(985));
        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326});

        dieListe.anhaengen(593);
        Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593});

        dieListe.einfuegenBei(0, 716);
        Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593});

        dieListe.anhaengen(679);
        Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679});

        dieListe.einfuegenBei(2, 243);
        Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 243, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679});

        dieListe.anhaengen(84);
        Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 243, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679, 84});

// 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);
        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, 70);
        Tester.pruefeListenInhalt(dieListe, new int[]{70});

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 740);
        Tester.pruefeListenInhalt(dieListe, new int[]{468, 565, 740});

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

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

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

        assertFalse("Fehler: Element 117 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(117));
        assertTrue("Fehler: Element 477 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(477));
        dieListe.einfuegenBei(2, 666);
        Tester.pruefeListenInhalt(dieListe, new int[]{565, 477, 666});

        dieListe.einfuegenBei(0, 255);
        Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 666});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477});

        dieListe.anhaengen(965);
        Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965});

        dieListe.anhaengen(503);
        Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965, 503});

        assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255));
        assertTrue("Fehler: Element 965 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(965));
        dieListe.einfuegenBei(5, 614);
        Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965, 503, 614});

        dieListe.einfuegenBei(3, 105);
        Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 105, 965, 503, 614});

    }

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

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

        assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996));
        dieListe.anhaengen(728);
        Tester.pruefeListenInhalt(dieListe, new int[]{435, 445, 728});

        dieListe.anhaengen(47);
        Tester.pruefeListenInhalt(dieListe, new int[]{435, 445, 728, 47});

        dieListe.einfuegenBei(0, 416);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47});

        assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47));
        dieListe.anhaengen(191);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191});

        dieListe.anhaengen(774);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191, 774});

        dieListe.anhaengen(779);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191, 774, 779});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779});

        dieListe.anhaengen(838);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838});

        dieListe.anhaengen(223);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 223});

        dieListe.anhaengen(96);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 223, 96});

        dieListe.einfuegenBei(8, 159);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 159, 223, 96});

        dieListe.anhaengen(815);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 159, 223, 96, 815});

        dieListe.einfuegenBei(7, 816);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 96, 815});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 815});

        dieListe.anhaengen(305);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 815, 305});

        assertFalse("Fehler: Element 300 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(300));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 816, 838, 159, 223, 815, 305});

        assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297));
        dieListe.anhaengen(932);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 816, 838, 159, 223, 815, 305, 932});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 816, 838, 159, 223, 815, 305, 932});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932});

        dieListe.anhaengen(396);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396});

        dieListe.anhaengen(351);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351});

        dieListe.anhaengen(267);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351, 267});

        dieListe.anhaengen(722);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351, 267, 722});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 396, 351, 267, 722});

        dieListe.einfuegenBei(9, 129);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722});

        assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267));
        dieListe.anhaengen(743);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743});

        dieListe.anhaengen(737);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 737});

        dieListe.anhaengen(579);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 737, 579});

        dieListe.entferneBei(16);
        Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 579});

        assertTrue("Fehler: Element 815 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(815));
// 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.anhaengen(993);
        Tester.pruefeListenInhalt(dieListe, new int[]{993});

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

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

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

        dieListe.anhaengen(344);
        Tester.pruefeListenInhalt(dieListe, new int[]{604, 228, 344});

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

        assertFalse("Fehler: Element 380 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(380));
        dieListe.anhaengen(146);
        Tester.pruefeListenInhalt(dieListe, new int[]{228, 344, 146});

        dieListe.anhaengen(232);
        Tester.pruefeListenInhalt(dieListe, new int[]{228, 344, 146, 232});

        dieListe.einfuegenBei(0, 956);
        Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 344, 146, 232});

        dieListe.anhaengen(446);
        Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 344, 146, 232, 446});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446});

        dieListe.anhaengen(646);
        Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446, 646});

        assertTrue("Fehler: Element 232 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(232));
        dieListe.anhaengen(226);
        Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446, 646, 226});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 232, 446, 646, 226});

        assertFalse("Fehler: Element 658 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(658));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{228, 232, 446, 646, 226});

        dieListe.anhaengen(670);
        Tester.pruefeListenInhalt(dieListe, new int[]{228, 232, 446, 646, 226, 670});

        dieListe.einfuegenBei(0, 294);
        Tester.pruefeListenInhalt(dieListe, new int[]{294, 228, 232, 446, 646, 226, 670});

        dieListe.einfuegenBei(0, 633);
        Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 228, 232, 446, 646, 226, 670});

        assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646));
        dieListe.einfuegenBei(3, 927);
        Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 228, 927, 232, 446, 646, 226, 670});

        assertFalse("Fehler: Element 815 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(815));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 927, 232, 446, 646, 226, 670});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 927, 232, 446, 226, 670});

        dieListe.einfuegenBei(0, 389);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670});

        dieListe.anhaengen(736);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 736});

        assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389));
        dieListe.anhaengen(369);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 736, 369});

        dieListe.einfuegenBei(8, 292);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369});

        dieListe.einfuegenBei(1, 445);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369});

        dieListe.anhaengen(554);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554});

        dieListe.anhaengen(861);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554, 861});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554});

        assertFalse("Fehler: Element 91 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(91));
// 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(153);
        Tester.pruefeListenInhalt(dieListe, new int[]{153});

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

        dieListe.anhaengen(309);
        Tester.pruefeListenInhalt(dieListe, new int[]{153, 145, 309});

        dieListe.einfuegenBei(2, 106);
        Tester.pruefeListenInhalt(dieListe, new int[]{153, 145, 106, 309});

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

        assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140));
        assertTrue("Fehler: Element 309 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(309));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{153, 106});

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

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

        dieListe.anhaengen(988);
        Tester.pruefeListenInhalt(dieListe, new int[]{153, 462, 988});

        dieListe.einfuegenBei(1, 123);
        Tester.pruefeListenInhalt(dieListe, new int[]{153, 123, 462, 988});

        dieListe.einfuegenBei(2, 704);
        Tester.pruefeListenInhalt(dieListe, new int[]{153, 123, 704, 462, 988});

// 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.einfuegenBei(0, 736);
        Tester.pruefeListenInhalt(dieListe, new int[]{736});

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

        dieListe.einfuegenBei(1, 169);
        Tester.pruefeListenInhalt(dieListe, new int[]{736, 169, 100});

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

        dieListe.anhaengen(540);
        Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 540});

        dieListe.anhaengen(486);
        Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 540, 486});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 486});

        dieListe.einfuegenBei(0, 866);
        Tester.pruefeListenInhalt(dieListe, new int[]{866, 736, 100, 486});

    }

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

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

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

        dieListe.einfuegenBei(0, 447);
        Tester.pruefeListenInhalt(dieListe, new int[]{447, 482, 651, 842});

        dieListe.anhaengen(414);
        Tester.pruefeListenInhalt(dieListe, new int[]{447, 482, 651, 842, 414});

        dieListe.einfuegenBei(1, 310);
        Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 651, 842, 414});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 651, 414});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 414});

        assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415));
        assertTrue("Fehler: Element 310 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(310));
        dieListe.einfuegenBei(1, 33);
        Tester.pruefeListenInhalt(dieListe, new int[]{447, 33, 310, 482, 414});

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

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

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

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

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

        assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644));
        dieListe.anhaengen(545);
        Tester.pruefeListenInhalt(dieListe, new int[]{474, 414, 545});

        dieListe.anhaengen(510);
        Tester.pruefeListenInhalt(dieListe, new int[]{474, 414, 545, 510});

        dieListe.einfuegenBei(0, 5);
        Tester.pruefeListenInhalt(dieListe, new int[]{5, 474, 414, 545, 510});

        dieListe.einfuegenBei(0, 745);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 474, 414, 545, 510});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 414, 545, 510});

        dieListe.anhaengen(962);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 414, 545, 510, 962});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 414, 545, 510, 962});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 510, 962});

        dieListe.einfuegenBei(2, 700);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962});

        dieListe.anhaengen(440);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962, 440});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962});

        dieListe.anhaengen(127);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962, 127});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 962, 127});

        dieListe.einfuegenBei(2, 569);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 127});

        dieListe.anhaengen(217);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 127, 217});

        assertFalse("Fehler: Element 357 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(357));
        assertFalse("Fehler: Element 166 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(166));
        dieListe.einfuegenBei(5, 503);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217});

        dieListe.anhaengen(22);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22});

        dieListe.einfuegenBei(9, 435);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435});

        dieListe.anhaengen(85);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85});

        dieListe.einfuegenBei(11, 870);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870});

        assertFalse("Fehler: Element 49 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(49));
        assertFalse("Fehler: Element 425 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(425));
        dieListe.anhaengen(878);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870, 878});

        dieListe.anhaengen(49);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870, 878, 49});

        assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569));
        assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 870, 878, 49});

        assertFalse("Fehler: Element 493 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(493));
        dieListe.anhaengen(421);
        Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 870, 878, 49, 421});

        assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421));
// 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);
        assertTrue(dieListe.istLeer());
        Tester.pruefeListenInhalt(dieListe, new int[]{});

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

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

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

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

        assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994));
        assertFalse("Fehler: Element 146 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(146));
        dieListe.anhaengen(31);
        Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31});

        dieListe.anhaengen(557);
        Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557});

        assertFalse("Fehler: Element 980 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(980));
        assertTrue("Fehler: Element 205 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(205));
        assertFalse("Fehler: Element 438 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(438));
        dieListe.anhaengen(55);
        Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557, 55});

        dieListe.anhaengen(463);
        Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557, 55, 463});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463});

        assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750));
        dieListe.anhaengen(709);
        Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463, 709});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463});

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

        dieListe.anhaengen(624);
        Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463, 624});

        assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842));
        dieListe.anhaengen(518);
        Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463, 624, 518});

        assertTrue("Fehler: Element 463 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(463));
        assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624, 518});

        assertTrue("Fehler: Element 624 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(624));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624});

        dieListe.anhaengen(217);
        Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624, 217});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624});

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

        dieListe.einfuegenBei(0, 363);
        Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 55, 624});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 624});

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

// 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, 73);
        Tester.pruefeListenInhalt(dieListe, new int[]{73});

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

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

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

        dieListe.einfuegenBei(2, 741);
        Tester.pruefeListenInhalt(dieListe, new int[]{957, 854, 741});

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

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

        dieListe.einfuegenBei(0, 607);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 598, 854, 741});

        dieListe.anhaengen(874);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 598, 854, 741, 874});

    }
}
