package tests;

import static org.junit.Assert.*;

import liste.*;

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


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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 114);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 0, 114, 922, 956});

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

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

        assertFalse("Fehler: Element 371 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(371));
        dieListe.anhaengen(215);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215});

        dieListe.anhaengen(718);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 718});

        dieListe.anhaengen(276);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 718, 276});

        dieListe.einfuegenBei(4, 788);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 788, 718, 276});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 788, 718, 276});

        assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 788, 276});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276});

        dieListe.anhaengen(832);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832});

        dieListe.anhaengen(102);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102});

        dieListe.anhaengen(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102, 7});

        assertFalse("Fehler: Element 240 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(240));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102});

        dieListe.einfuegenBei(0, 393);
        Tester.pruefeListenInhalt(dieListe, new int[]{393, 607, 956, 788, 276, 832, 102});

        dieListe.einfuegenBei(1, 691);
        Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 956, 788, 276, 832, 102});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 276, 832, 102});

        assertFalse("Fehler: Element 886 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(886));
        dieListe.anhaengen(344);
        Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 276, 832, 102, 344});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 102, 344});

        dieListe.einfuegenBei(5, 109);
        Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 109, 102, 344});

        assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190));
        dieListe.anhaengen(970);
        Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 109, 102, 344, 970});

        assertFalse("Fehler: Element 766 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(766));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 344, 970});

        dieListe.einfuegenBei(6, 497);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 344, 970});

        assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 344});

        assertTrue("Fehler: Element 691 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(691));
        dieListe.einfuegenBei(7, 665);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 665, 344});

        assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212));
        dieListe.einfuegenBei(4, 659);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 109, 102, 497, 665, 344});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 109, 497, 665, 344});

        dieListe.einfuegenBei(5, 493);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 493, 109, 497, 665, 344});

        assertTrue("Fehler: Element 344 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(344));
        assertTrue("Fehler: Element 691 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(691));
        assertFalse("Fehler: Element 539 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(539));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 493, 109, 497, 344});

        dieListe.einfuegenBei(3, 819);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 819, 832, 659, 493, 109, 497, 344});

        assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672));
        dieListe.einfuegenBei(10, 387);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 819, 832, 659, 493, 109, 497, 344, 387});

        dieListe.einfuegenBei(3, 805);
        Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 805, 819, 832, 659, 493, 109, 497, 344, 387});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 497, 344, 387});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 344, 387});

        assertTrue("Fehler: Element 819 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(819));
        dieListe.einfuegenBei(10, 722);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 344, 387, 722});

        assertFalse("Fehler: Element 39 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(39));
        assertFalse("Fehler: Element 739 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(739));
        dieListe.einfuegenBei(2, 757);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 387, 722});

        dieListe.einfuegenBei(10, 857);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 857, 387, 722});

        dieListe.anhaengen(96);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 857, 387, 722, 96});

        dieListe.einfuegenBei(10, 37);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 722, 96});

        dieListe.anhaengen(426);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 722, 96, 426});

        dieListe.einfuegenBei(13, 503);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 503, 722, 96, 426});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 503, 722, 96, 426});

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

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

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

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

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

        dieListe.anhaengen(213);
        Tester.pruefeListenInhalt(dieListe, new int[]{825, 627, 213});

        dieListe.anhaengen(566);
        Tester.pruefeListenInhalt(dieListe, new int[]{825, 627, 213, 566});

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 32);
        Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 755});

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

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 695});

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

        dieListe.einfuegenBei(1, 53);
        Tester.pruefeListenInhalt(dieListe, new int[]{280, 53, 117, 695});

        dieListe.einfuegenBei(4, 846);
        Tester.pruefeListenInhalt(dieListe, new int[]{280, 53, 117, 695, 846});

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

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

        dieListe.anhaengen(515);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515});

        dieListe.einfuegenBei(6, 471);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471});

        dieListe.anhaengen(73);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 73});

        assertTrue("Fehler: Element 846 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(846));
        assertFalse("Fehler: Element 65 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(65));
        dieListe.einfuegenBei(7, 273);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 273, 73});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 73});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 73});

        dieListe.anhaengen(99);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 73, 99});

        dieListe.einfuegenBei(2, 644);
        Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 644, 695, 846, 242, 515, 73, 99});

    }

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

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

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

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

        dieListe.einfuegenBei(2, 277);
        Tester.pruefeListenInhalt(dieListe, new int[]{357, 214, 277});

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

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

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

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

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

        dieListe.einfuegenBei(2, 245);
        Tester.pruefeListenInhalt(dieListe, new int[]{771, 619, 245});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114));
        assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114));
        dieListe.anhaengen(940);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 940});

        assertFalse("Fehler: Element 641 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(641));
        dieListe.einfuegenBei(4, 59);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 59, 940});

        assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149));
        dieListe.anhaengen(488);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 59, 940, 488});

        assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149));
        assertFalse("Fehler: Element 390 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(390));
        dieListe.einfuegenBei(3, 614);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 614, 323, 59, 940, 488});

        dieListe.einfuegenBei(2, 557);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488});

        dieListe.anhaengen(908);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908});

        dieListe.anhaengen(155);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908, 155});

        dieListe.anhaengen(596);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908, 155, 596});

        dieListe.einfuegenBei(5, 416);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 416, 323, 59, 940, 488, 908, 155, 596});

        dieListe.einfuegenBei(2, 832);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 488, 908, 155, 596});

        dieListe.einfuegenBei(10, 600);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 600, 488, 908, 155, 596});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 600, 908, 155, 596});

        dieListe.einfuegenBei(9, 466);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596});

        dieListe.anhaengen(670);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596, 670});

        dieListe.anhaengen(762);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596, 670, 762});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762});

        dieListe.einfuegenBei(16, 813);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813});

        dieListe.anhaengen(759);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813, 759});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813, 759});

        assertFalse("Fehler: Element 783 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(783));
        dieListe.einfuegenBei(15, 961);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759});

        dieListe.anhaengen(732);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759, 732});

        dieListe.einfuegenBei(4, 414);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759, 732});

        assertTrue("Fehler: Element 832 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(832));
        dieListe.einfuegenBei(14, 879);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732});

        dieListe.einfuegenBei(8, 971);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 971, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732});

        dieListe.einfuegenBei(9, 743);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732});

        dieListe.einfuegenBei(5, 836);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732});

        dieListe.entferneBei(16);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 670, 762, 961, 813, 759, 732});

        assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961));
        dieListe.entferneBei(22);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 670, 762, 961, 813, 759});

        dieListe.einfuegenBei(17, 173);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 173, 670, 762, 961, 813, 759});

        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759});

        dieListe.einfuegenBei(5, 97);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759});

        assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59));
        dieListe.einfuegenBei(1, 301);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759});

        assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114));
        dieListe.einfuegenBei(21, 884);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759});

        dieListe.anhaengen(974);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759, 974});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759, 974});

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

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

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

        dieListe.anhaengen(944);
        Tester.pruefeListenInhalt(dieListe, new int[]{812, 57, 944});

        dieListe.anhaengen(400);
        Tester.pruefeListenInhalt(dieListe, new int[]{812, 57, 944, 400});

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

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

        dieListe.einfuegenBei(1, 930);
        Tester.pruefeListenInhalt(dieListe, new int[]{944, 930, 400});

        dieListe.anhaengen(626);
        Tester.pruefeListenInhalt(dieListe, new int[]{944, 930, 400, 626});

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

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

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

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

        dieListe.anhaengen(321);
        Tester.pruefeListenInhalt(dieListe, new int[]{930, 626, 321});

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

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

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

        dieListe.anhaengen(118);
        Tester.pruefeListenInhalt(dieListe, new int[]{930, 583, 118});

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

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

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

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

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

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

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

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

        dieListe.anhaengen(17);
        Tester.pruefeListenInhalt(dieListe, new int[]{486, 973, 44, 17});

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

        dieListe.anhaengen(126);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 126});

        dieListe.einfuegenBei(4, 515);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 126, 515});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 515});

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

        dieListe.einfuegenBei(1, 845);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 17, 515, 239});

        dieListe.einfuegenBei(3, 462);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 462, 17, 515, 239});

        dieListe.einfuegenBei(3, 247);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 247, 462, 17, 515, 239});

        assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759));
        dieListe.einfuegenBei(3, 118);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 247, 462, 17, 515, 239});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 247, 462, 17, 239});

        dieListe.einfuegenBei(4, 201);
        Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 201, 247, 462, 17, 239});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 118, 201, 247, 462, 17, 239});

        dieListe.anhaengen(51);
        Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 118, 201, 247, 462, 17, 239, 51});

        assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 201, 247, 462, 17, 239, 51});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 201, 247, 462, 239, 51});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51});

        dieListe.anhaengen(694);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51, 694});

        dieListe.anhaengen(700);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51, 694, 700});

        assertFalse("Fehler: Element 497 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(497));
        assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475));
        dieListe.einfuegenBei(5, 264);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 264, 51, 694, 700});

        dieListe.einfuegenBei(1, 353);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 353, 201, 247, 462, 239, 264, 51, 694, 700});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 353, 201, 247, 462, 239, 264, 694, 700});

        dieListe.einfuegenBei(1, 974);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 462, 239, 264, 694, 700});

        dieListe.einfuegenBei(5, 874);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 874, 462, 239, 264, 694, 700});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 874, 239, 264, 694, 700});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 264, 694, 700});

        dieListe.einfuegenBei(6, 26);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 694, 700});

        assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 700});

        assertFalse("Fehler: Element 993 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(993));
        dieListe.anhaengen(882);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 700, 882});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 882});

        assertFalse("Fehler: Element 680 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(680));
        dieListe.einfuegenBei(2, 340);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 340, 353, 201, 247, 239, 26, 264, 882});

        assertFalse("Fehler: Element 896 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(896));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 882});

        dieListe.einfuegenBei(4, 389);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 26, 264, 882});

        dieListe.anhaengen(299);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 26, 264, 882, 299});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299});

        dieListe.einfuegenBei(3, 195);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 389, 247, 239, 264, 882, 299});

        assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195));
        dieListe.anhaengen(613);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 389, 247, 239, 264, 882, 299, 613});

        dieListe.einfuegenBei(5, 611);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 611, 389, 247, 239, 264, 882, 299, 613});

        assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613});

        dieListe.anhaengen(242);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242});

        assertFalse("Fehler: Element 75 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(75));
        assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389));
        dieListe.einfuegenBei(13, 140);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140});

        assertFalse("Fehler: Element 388 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(388));
        dieListe.anhaengen(288);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 288});

        assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759));
        dieListe.entferneBei(14);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140});

        dieListe.anhaengen(352);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352});

        dieListe.anhaengen(363);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363});

        assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264));
        dieListe.anhaengen(218);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218});

        dieListe.anhaengen(644);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 644});

        dieListe.einfuegenBei(16, 756);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644});

        dieListe.anhaengen(900);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644, 900});

        dieListe.einfuegenBei(15, 183);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 183, 218, 756, 644, 900});

        assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644));
        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644, 900});

        dieListe.einfuegenBei(14, 348);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 348, 363, 218, 756, 644, 900});

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

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

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

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

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

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

        dieListe.anhaengen(647);
        Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 647});

        dieListe.einfuegenBei(3, 463);
        Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 463, 647});

        dieListe.einfuegenBei(3, 826);
        Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 826, 463, 647});

        dieListe.einfuegenBei(1, 532);
        Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 667, 452, 826, 463, 647});

        dieListe.einfuegenBei(5, 90);
        Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 667, 452, 826, 90, 463, 647});

        assertTrue("Fehler: Element 647 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(647));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 452, 826, 90, 463, 647});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 452, 826, 90, 647});

        assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265));
        dieListe.einfuegenBei(0, 669);
        Tester.pruefeListenInhalt(dieListe, new int[]{669, 504, 532, 452, 826, 90, 647});

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

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

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

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

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

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

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

    }

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

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

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

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

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

        assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306));
        dieListe.anhaengen(920);
        Tester.pruefeListenInhalt(dieListe, new int[]{61, 705, 124, 920});

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

        dieListe.einfuegenBei(0, 569);
        Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920});

        dieListe.anhaengen(963);
        Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963});

        dieListe.anhaengen(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6});

        dieListe.anhaengen(749);
        Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6, 749});

        dieListe.anhaengen(883);
        Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6, 749, 883});

        dieListe.einfuegenBei(0, 875);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 963, 6, 749, 883});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 6, 749, 883});

        dieListe.einfuegenBei(5, 554);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 554, 6, 749, 883});

        assertFalse("Fehler: Element 165 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(165));
        assertFalse("Fehler: Element 444 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(444));
        dieListe.einfuegenBei(6, 313);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 554, 313, 6, 749, 883});

        dieListe.einfuegenBei(3, 949);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 6, 749, 883});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 6, 883});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 883});

        dieListe.einfuegenBei(3, 449);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 920, 554, 313, 883});

        assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486));
        assertTrue("Fehler: Element 705 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(705));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883});

        dieListe.einfuegenBei(9, 788);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883, 788});

        assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335));
        dieListe.anhaengen(170);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883, 788, 170});

        dieListe.einfuegenBei(4, 10);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 554, 313, 883, 788, 170});

        dieListe.anhaengen(431);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 554, 313, 883, 788, 170, 431});

        assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161));
        assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542));
        assertFalse("Fehler: Element 726 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(726));
        assertTrue("Fehler: Element 875 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(875));
        assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569));
        dieListe.einfuegenBei(7, 949);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 554, 313, 883, 788, 170, 431});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 554, 313, 883, 788, 431});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 313, 883, 788, 431});

        assertTrue("Fehler: Element 875 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(875));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 788, 431});

        dieListe.einfuegenBei(9, 600);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431});

        assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93));
        assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368));
        dieListe.anhaengen(212);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 212});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431});

        dieListe.anhaengen(575);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575});

        dieListe.anhaengen(157);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575, 157});

        dieListe.anhaengen(838);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575, 157, 838});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 157, 838});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 157});

        dieListe.einfuegenBei(12, 980);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 980, 157});

        dieListe.anhaengen(677);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 980, 157, 677});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 575, 980, 157, 677});

        dieListe.einfuegenBei(9, 693);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677});

        dieListe.anhaengen(37);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37});

        dieListe.anhaengen(212);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37, 212});

        dieListe.anhaengen(838);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37, 212, 838});

        dieListe.einfuegenBei(9, 427);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 980, 157, 677, 37, 212, 838});

        dieListe.anhaengen(971);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 980, 157, 677, 37, 212, 838, 971});

        dieListe.einfuegenBei(13, 708);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 677, 37, 212, 838, 971});

        dieListe.entferneBei(16);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 37, 212, 838, 971});

        dieListe.einfuegenBei(16, 67);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 67, 37, 212, 838, 971});

        dieListe.einfuegenBei(15, 133);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971});

        dieListe.einfuegenBei(6, 525);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971});

        dieListe.einfuegenBei(4, 977);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 977, 949, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971});

        assertTrue("Fehler: Element 600 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(600));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 977, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971});

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

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

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

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

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

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

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

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

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

        assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644));
        dieListe.anhaengen(686);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413, 686});

        assertFalse("Fehler: Element 804 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(804));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413});

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

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

        dieListe.einfuegenBei(4, 685);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 685});

        assertFalse("Fehler: Element 87 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(87));
        assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884));
        assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413));
        assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881});

        dieListe.anhaengen(897);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 897});

        dieListe.anhaengen(300);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 897, 300});

        dieListe.einfuegenBei(1, 396);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 396, 644, 413, 881, 897, 300});

        assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300));
        assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413));
        assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884));
        dieListe.einfuegenBei(6, 568);
        Tester.pruefeListenInhalt(dieListe, new int[]{884, 396, 644, 413, 881, 897, 568, 300});

    }

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 74);
        Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914});

        assertFalse("Fehler: Element 787 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(787));
        dieListe.anhaengen(846);
        Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914, 846});

        dieListe.anhaengen(95);
        Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914, 846, 95});

        dieListe.einfuegenBei(0, 562);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 846, 95});

        dieListe.einfuegenBei(6, 84);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 846, 95, 84});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 95, 84});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 74, 914, 95, 84});

        assertFalse("Fehler: Element 182 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(182));
        assertFalse("Fehler: Element 495 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(495));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 74, 914, 84});

        dieListe.einfuegenBei(1, 556);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84});

        dieListe.einfuegenBei(1, 813);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 813, 556, 74, 914, 84});

        dieListe.anhaengen(640);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 813, 556, 74, 914, 84, 640});

        assertFalse("Fehler: Element 601 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(601));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640});

        dieListe.einfuegenBei(1, 365);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640});

        dieListe.anhaengen(126);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 126});

        dieListe.einfuegenBei(7, 955);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126});

        dieListe.anhaengen(309);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309});

        assertFalse("Fehler: Element 638 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(638));
        assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765));
        dieListe.anhaengen(551);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309, 551});

        dieListe.anhaengen(347);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309, 551, 347});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 309, 551, 347});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 551, 347});

        dieListe.anhaengen(995);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 551, 347, 995});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 551, 347, 995});

        assertTrue("Fehler: Element 640 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(640));
        assertFalse("Fehler: Element 864 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(864));
        dieListe.einfuegenBei(7, 115);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 115, 551, 347, 995});

        dieListe.anhaengen(568);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 115, 551, 347, 995, 568});

        dieListe.einfuegenBei(2, 54);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 84, 640, 955, 115, 551, 347, 995, 568});

        dieListe.einfuegenBei(5, 939);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 939, 84, 640, 955, 115, 551, 347, 995, 568});

        assertTrue("Fehler: Element 84 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(84));
        dieListe.einfuegenBei(8, 790);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568});

        assertTrue("Fehler: Element 84 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(84));
        dieListe.anhaengen(589);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589});

        dieListe.anhaengen(83);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589, 83});

        dieListe.einfuegenBei(9, 267);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83});

        dieListe.anhaengen(131);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83, 131});

        dieListe.einfuegenBei(6, 602);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 602, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83, 131});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 602, 790, 115, 267, 551, 347, 995, 568, 589, 83, 131});

        dieListe.einfuegenBei(6, 397);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 397, 602, 790, 115, 267, 551, 347, 995, 568, 589, 83, 131});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(646);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646});

        assertFalse("Fehler: Element 697 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(697));
        dieListe.anhaengen(611);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646, 611});

        dieListe.anhaengen(159);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646, 611, 159});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 646, 611, 159});

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

        dieListe.einfuegenBei(3, 86);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159, 86});

        assertTrue("Fehler: Element 159 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(159));
        dieListe.anhaengen(535);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159, 86, 535});

        dieListe.einfuegenBei(2, 607);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535});

        dieListe.anhaengen(445);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535, 445});

        assertFalse("Fehler: Element 794 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(794));
        dieListe.anhaengen(153);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535, 445, 153});

        dieListe.einfuegenBei(1, 866);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 445, 153});

        dieListe.anhaengen(574);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 445, 153, 574});

        dieListe.einfuegenBei(7, 169);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574});

        dieListe.anhaengen(707);
        Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707});

        dieListe.einfuegenBei(0, 911);
        Tester.pruefeListenInhalt(dieListe, new int[]{911, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707});

        assertFalse("Fehler: Element 476 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(476));
        dieListe.anhaengen(353);
        Tester.pruefeListenInhalt(dieListe, new int[]{911, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707, 353});

        dieListe.einfuegenBei(1, 459);
        Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707, 353});

        dieListe.einfuegenBei(6, 431);
        Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 574, 707, 353});

        assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672));
        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 707, 353});

        dieListe.einfuegenBei(0, 87);
        Tester.pruefeListenInhalt(dieListe, new int[]{87, 911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 707, 353});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{87, 911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 707, 353});

    }

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

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

        assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714));
        dieListe.einfuegenBei(0, 175);
        Tester.pruefeListenInhalt(dieListe, new int[]{175, 421, 83});

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(3, 1);
        Tester.pruefeListenInhalt(dieListe, new int[]{175, 117, 664, 1});

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

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

        dieListe.einfuegenBei(2, 234);
        Tester.pruefeListenInhalt(dieListe, new int[]{661, 285, 234});

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

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

        assertFalse("Fehler: Element 227 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(227));
        assertFalse("Fehler: Element 735 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(735));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{285, 234});

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

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

        dieListe.einfuegenBei(1, 617);
        Tester.pruefeListenInhalt(dieListe, new int[]{234, 617, 769});

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

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

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

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

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

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

        assertFalse("Fehler: Element 806 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(806));
        assertTrue("Fehler: Element 976 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(976));
        dieListe.anhaengen(666);
        Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666});

        dieListe.anhaengen(983);
        Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666, 983});

        dieListe.anhaengen(428);
        Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666, 983, 428});

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

        assertFalse("Fehler: Element 517 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(517));
        dieListe.anhaengen(778);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 666, 983, 428, 778});

        dieListe.einfuegenBei(2, 424);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 424, 666, 983, 428, 778});

        assertTrue("Fehler: Element 424 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(424));
        assertFalse("Fehler: Element 891 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(891));
        assertFalse("Fehler: Element 81 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(81));
        dieListe.einfuegenBei(1, 208);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 666, 983, 428, 778});

        assertFalse("Fehler: Element 809 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(809));
        dieListe.anhaengen(623);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 666, 983, 428, 778, 623});

        dieListe.einfuegenBei(4, 412);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 778, 623});

        dieListe.anhaengen(321);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 778, 623, 321});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 623, 321});

        dieListe.einfuegenBei(10, 658);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 623, 321, 658});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 321, 658});

        assertFalse("Fehler: Element 924 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(924));
        dieListe.anhaengen(719);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 321, 658, 719});

        dieListe.einfuegenBei(8, 367);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 719});

        dieListe.einfuegenBei(12, 35);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 719, 35});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 35});

        dieListe.einfuegenBei(7, 973);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35});

        assertTrue("Fehler: Element 412 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(412));
        dieListe.anhaengen(840);
        Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840});

        dieListe.anhaengen(95);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840, 95});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 35, 840, 95});

        dieListe.einfuegenBei(7, 499);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 840, 95});

        assertFalse("Fehler: Element 599 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(599));
        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95});

        dieListe.anhaengen(448);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95, 448});

        assertFalse("Fehler: Element 296 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(296));
        dieListe.anhaengen(105);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95, 448, 105});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 321, 35, 95, 448, 105});

        assertFalse("Fehler: Element 903 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(903));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 321, 95, 448, 105});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 95, 448, 105});

        dieListe.einfuegenBei(12, 42);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 95, 448, 105, 42});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 95, 448, 105, 42});

        assertFalse("Fehler: Element 317 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(317));
        assertTrue("Fehler: Element 42 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(42));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 448, 105, 42});

        dieListe.anhaengen(874);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 448, 105, 42, 874});

        assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 623, 448, 105, 42, 874});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 983, 428, 973, 623, 448, 105, 42, 874});

        dieListe.einfuegenBei(2, 120);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 120, 983, 428, 973, 623, 448, 105, 42, 874});

        dieListe.einfuegenBei(4, 683);
        Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 120, 983, 683, 428, 973, 623, 448, 105, 42, 874});

    }

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

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

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

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

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

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

        dieListe.anhaengen(725);
        Tester.pruefeListenInhalt(dieListe, new int[]{3, 85, 725});

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

        dieListe.anhaengen(707);
        Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707});

        assertFalse("Fehler: Element 523 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(523));
        assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707));
        dieListe.anhaengen(455);
        Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707, 455});

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

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

        dieListe.einfuegenBei(3, 454);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 454, 196});

        dieListe.anhaengen(489);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 454, 196, 489});

        assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707));
        assertTrue("Fehler: Element 196 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(196));
        dieListe.einfuegenBei(3, 772);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489});

        dieListe.anhaengen(672);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672});

        assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368));
        assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489));
        assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672));
        dieListe.anhaengen(79);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672, 79});

        dieListe.anhaengen(219);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672, 79, 219});

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

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

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

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

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

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 982 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(982));
        dieListe.anhaengen(688);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688});

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

        dieListe.einfuegenBei(3, 763);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 763, 377});

        assertFalse("Fehler: Element 206 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(206));
        assertFalse("Fehler: Element 461 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(461));
        dieListe.einfuegenBei(4, 306);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 763, 306, 377});

        dieListe.einfuegenBei(1, 175);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 409, 688, 763, 306, 377});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 306, 377});

        dieListe.einfuegenBei(4, 148);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377});

        dieListe.anhaengen(675);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377, 675});

        dieListe.einfuegenBei(7, 893);
        Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377, 893, 675});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{175, 688, 763, 148, 306, 377, 893, 675});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{175, 688, 763, 306, 377, 893, 675});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 377, 893, 675});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 675});

        assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68));
        dieListe.einfuegenBei(4, 97);
        Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675});

        assertFalse("Fehler: Element 348 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(348));
        dieListe.anhaengen(868);
        Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675, 868});

        dieListe.anhaengen(688);
        Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675, 868, 688});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{688, 306, 893, 97, 675, 868, 688});

// 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[]{});

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

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

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

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

        dieListe.anhaengen(92);
        Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92});

        dieListe.einfuegenBei(4, 695);
        Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 695});

        dieListe.einfuegenBei(4, 157);
        Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 157, 695});

        assertTrue("Fehler: Element 692 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(692));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 695});

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

        dieListe.anhaengen(170);
        Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 695, 170});

        dieListe.einfuegenBei(3, 159);
        Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 159, 695, 170});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 159, 170});

        dieListe.einfuegenBei(1, 7);
        Tester.pruefeListenInhalt(dieListe, new int[]{130, 7, 692, 92, 159, 170});

        assertFalse("Fehler: Element 216 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(216));
        dieListe.einfuegenBei(0, 828);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170});

        assertFalse("Fehler: Element 913 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(913));
        dieListe.anhaengen(526);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526});

        dieListe.anhaengen(634);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526, 634});

        dieListe.anhaengen(576);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526, 634, 576});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 692, 92, 159, 170, 526, 634, 576});

        dieListe.einfuegenBei(2, 967);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576});

        dieListe.anhaengen(530);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530});

        dieListe.anhaengen(612);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 612});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530});

        dieListe.einfuegenBei(1, 941);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530});

        assertTrue("Fehler: Element 828 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(828));
        assertTrue("Fehler: Element 941 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(941));
        dieListe.anhaengen(220);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 220});

        dieListe.anhaengen(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 220, 11});

        assertFalse("Fehler: Element 734 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(734));
        dieListe.einfuegenBei(5, 335);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 335, 92, 159, 170, 526, 634, 576, 530, 220, 11});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 335, 159, 170, 526, 634, 576, 530, 220, 11});

        assertTrue("Fehler: Element 130 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(130));
        dieListe.einfuegenBei(1, 469);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 469, 941, 130, 967, 692, 335, 159, 170, 526, 634, 576, 530, 220, 11});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{828, 469, 941, 130, 967, 692, 335, 159, 170, 526, 634, 530, 220, 11});

    }

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

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

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

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

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

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

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

        dieListe.anhaengen(850);
        Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21, 502, 527, 850});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{709, 21, 502, 527, 850});

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

        assertFalse("Fehler: Element 584 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(584));
        dieListe.einfuegenBei(0, 364);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850});

        dieListe.anhaengen(89);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 89});

        dieListe.anhaengen(710);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 89, 710});

        assertTrue("Fehler: Element 710 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(710));
        dieListe.einfuegenBei(5, 185);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 185, 89, 710});

        dieListe.einfuegenBei(4, 862);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710});

        dieListe.anhaengen(24);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24});

        assertTrue("Fehler: Element 364 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(364));
        dieListe.anhaengen(391);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391});

        assertTrue("Fehler: Element 850 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(850));
        assertTrue("Fehler: Element 185 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(185));
        dieListe.anhaengen(355);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391, 355});

        dieListe.anhaengen(174);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391, 355, 174});

        dieListe.einfuegenBei(9, 732);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 174});

        dieListe.anhaengen(137);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 174, 137});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 137});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137});

        dieListe.anhaengen(326);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326});

        dieListe.anhaengen(883);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883});

        dieListe.einfuegenBei(4, 60);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883});

        dieListe.anhaengen(140);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140});

        assertFalse("Fehler: Element 792 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(792));
        dieListe.einfuegenBei(5, 368);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 368, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140});

        dieListe.einfuegenBei(11, 236);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140});

        assertTrue("Fehler: Element 326 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(326));
        dieListe.einfuegenBei(8, 78);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140});

        dieListe.einfuegenBei(6, 120);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 137, 326, 883, 140});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 326, 883, 140});

        dieListe.anhaengen(234);
        Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 326, 883, 140, 234});

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

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

        dieListe.anhaengen(707);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 931, 707});

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

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

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

        dieListe.anhaengen(463);
        Tester.pruefeListenInhalt(dieListe, new int[]{77, 103, 931, 428, 463});

        dieListe.einfuegenBei(0, 128);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 103, 931, 428, 463});

        dieListe.anhaengen(689);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 103, 931, 428, 463, 689});

        assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689});

        dieListe.anhaengen(135);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135});

        dieListe.anhaengen(99);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135, 99});

        dieListe.anhaengen(192);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135, 99, 192});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 135, 99, 192});

        dieListe.einfuegenBei(7, 905);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 135, 99, 905, 192});

        dieListe.einfuegenBei(1, 44);
        Tester.pruefeListenInhalt(dieListe, new int[]{128, 44, 77, 931, 428, 463, 135, 99, 905, 192});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 99, 905, 192});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 905, 192});

        assertFalse("Fehler: Element 580 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(580));
        dieListe.einfuegenBei(8, 815);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 905, 192, 815});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 905, 192, 815});

        dieListe.einfuegenBei(6, 300);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 905, 300, 192, 815});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 905, 300, 192, 815});

        dieListe.einfuegenBei(1, 607);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815});

        dieListe.anhaengen(672);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672});

        dieListe.anhaengen(575);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575});

        assertFalse("Fehler: Element 670 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(670));
        dieListe.anhaengen(133);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133});

        dieListe.anhaengen(967);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133, 967});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133});

        assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300));
        assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44));
        assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985));
        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 575, 133});

        assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428));
        dieListe.anhaengen(906);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 575, 133, 906});

        assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77));
        assertFalse("Fehler: Element 793 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(793));
        dieListe.einfuegenBei(5, 789);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906});

        assertTrue("Fehler: Element 906 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(906));
        dieListe.anhaengen(548);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548});

        dieListe.anhaengen(471);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548, 471});

        assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300));
        dieListe.einfuegenBei(15, 540);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548, 471, 540});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 815, 575, 133, 906, 548, 471, 540});

        assertFalse("Fehler: Element 541 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(541));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540});

        dieListe.anhaengen(999);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999});

        assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931));
        dieListe.anhaengen(382);
        Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999, 382});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999, 382});

    }

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

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

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

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

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

        dieListe.einfuegenBei(3, 382);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382});

        dieListe.einfuegenBei(4, 168);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168});

        assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890));
        dieListe.anhaengen(849);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 849});

        assertTrue("Fehler: Element 948 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(948));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168});

        dieListe.anhaengen(225);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225});

        dieListe.einfuegenBei(6, 56);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225, 56});

        dieListe.einfuegenBei(6, 256);
        Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225, 256, 56});

        dieListe.einfuegenBei(0, 47);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 168, 225, 256, 56});

        dieListe.einfuegenBei(5, 723);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56});

        dieListe.anhaengen(867);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56, 867});

        dieListe.anhaengen(497);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497});

        dieListe.einfuegenBei(8, 780);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497});

        dieListe.anhaengen(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497, 11});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497, 11});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497, 11});

        dieListe.anhaengen(832);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497, 11, 832});

        dieListe.einfuegenBei(4, 283);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832});

        dieListe.anhaengen(453);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832, 453});

        dieListe.einfuegenBei(5, 598);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 11, 832, 453});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 453});

        dieListe.anhaengen(859);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 453, 859});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859});

        assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802));
        dieListe.anhaengen(793);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793});

        assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598));
        dieListe.anhaengen(180);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180});

        dieListe.einfuegenBei(1, 420);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180});

        dieListe.anhaengen(392);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 392});

        dieListe.entferneBei(17);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180});

        assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239));
        dieListe.einfuegenBei(7, 593);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180});

        dieListe.einfuegenBei(17, 832);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832});

        assertTrue("Fehler: Element 832 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(832));
        dieListe.einfuegenBei(4, 505);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832});

        dieListe.einfuegenBei(14, 19);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832});

        dieListe.anhaengen(631);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631});

        dieListe.anhaengen(534);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534});

        dieListe.einfuegenBei(5, 395);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534});

        dieListe.anhaengen(718);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534, 718});

        dieListe.anhaengen(144);
        Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534, 718, 144});

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 276);
        Tester.pruefeListenInhalt(dieListe, new int[]{868, 276, 490});

        dieListe.einfuegenBei(2, 339);
        Tester.pruefeListenInhalt(dieListe, new int[]{868, 276, 339, 490});

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

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

        dieListe.einfuegenBei(2, 990);
        Tester.pruefeListenInhalt(dieListe, new int[]{868, 339, 990});

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

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

        assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725));
        dieListe.einfuegenBei(2, 738);
        Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 738, 990});

        assertFalse("Fehler: Element 615 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(615));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 990});

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

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

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

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

        dieListe.anhaengen(718);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 185, 637, 718});

        assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637));
        assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718));
        assertFalse("Fehler: Element 442 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(442));
        assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{185, 637, 718});

        dieListe.einfuegenBei(3, 92);
        Tester.pruefeListenInhalt(dieListe, new int[]{185, 637, 718, 92});

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

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

        dieListe.anhaengen(597);
        Tester.pruefeListenInhalt(dieListe, new int[]{718, 92, 597});

        dieListe.einfuegenBei(1, 401);
        Tester.pruefeListenInhalt(dieListe, new int[]{718, 401, 92, 597});

        dieListe.einfuegenBei(3, 937);
        Tester.pruefeListenInhalt(dieListe, new int[]{718, 401, 92, 937, 597});

        dieListe.einfuegenBei(0, 239);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 401, 92, 937, 597});

        assertTrue("Fehler: Element 597 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(597));
        dieListe.anhaengen(251);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 401, 92, 937, 597, 251});

        dieListe.einfuegenBei(2, 492);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251});

        dieListe.anhaengen(704);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251, 704});

        assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401));
        assertFalse("Fehler: Element 681 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(681));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251});

    }

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 118);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 403, 118});

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

        dieListe.anhaengen(905);
        Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905});

        dieListe.einfuegenBei(3, 135);
        Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135});

        assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118));
        dieListe.anhaengen(391);
        Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135, 391});

        dieListe.anhaengen(452);
        Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135, 391, 452});

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

        dieListe.anhaengen(508);
        Tester.pruefeListenInhalt(dieListe, new int[]{118, 905, 135, 391, 452, 508});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{118, 135, 391, 452, 508});

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

        assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135));
        dieListe.einfuegenBei(3, 68);
        Tester.pruefeListenInhalt(dieListe, new int[]{135, 391, 452, 68, 508});

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(991);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 81, 991});

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

        dieListe.einfuegenBei(2, 292);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 81, 292});

        dieListe.einfuegenBei(1, 379);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292});

        dieListe.anhaengen(634);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 634});

        dieListe.einfuegenBei(5, 319);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 634, 319});

        assertTrue("Fehler: Element 700 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(700));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 319});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292});

        dieListe.anhaengen(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4});

        dieListe.anhaengen(274);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4, 274});

        assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274));
        assertTrue("Fehler: Element 4 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(4));
        dieListe.anhaengen(822);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4, 274, 822});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 292, 4, 274, 822});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 4, 274, 822});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 4, 822});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 822});

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

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

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

        assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847));
        dieListe.einfuegenBei(0, 366);
        Tester.pruefeListenInhalt(dieListe, new int[]{366, 292, 203});

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

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

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

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

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

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

        dieListe.einfuegenBei(3, 813);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 400, 813});

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

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

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

        dieListe.einfuegenBei(1, 509);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 366, 813, 881, 172});

        assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772));
        dieListe.einfuegenBei(6, 355);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 366, 813, 881, 172, 355});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 813, 881, 172, 355});

        dieListe.anhaengen(247);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 813, 881, 172, 355, 247});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 881, 172, 355, 247});

        dieListe.einfuegenBei(1, 543);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 881, 172, 355, 247});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 172, 355, 247});

        dieListe.einfuegenBei(6, 59);
        Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 172, 355, 247, 59});

        assertFalse("Fehler: Element 705 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(705));
        dieListe.einfuegenBei(0, 334);
        Tester.pruefeListenInhalt(dieListe, new int[]{334, 778, 543, 509, 172, 355, 247, 59});

        dieListe.einfuegenBei(0, 137);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 509, 172, 355, 247, 59});

        dieListe.einfuegenBei(8, 339);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 509, 172, 355, 247, 339, 59});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 172, 355, 247, 339, 59});

        dieListe.einfuegenBei(4, 754);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59});

        dieListe.anhaengen(61);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59, 61});

        dieListe.anhaengen(447);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59, 61, 447});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 339, 59, 61, 447});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 754, 172, 355, 339, 59, 61, 447});

        assertFalse("Fehler: Element 138 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(138));
        dieListe.einfuegenBei(2, 18);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 61, 447});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 447});

        dieListe.einfuegenBei(7, 355);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 355, 339, 59, 447});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 447});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 355, 339, 59, 447});

        dieListe.einfuegenBei(1, 666);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 778, 754, 355, 339, 59, 447});

        dieListe.einfuegenBei(4, 343);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 447});

        dieListe.einfuegenBei(10, 268);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 268, 447});

        dieListe.einfuegenBei(10, 539);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447});

        dieListe.anhaengen(968);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447, 968});

        dieListe.anhaengen(186);
        Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447, 968, 186});

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

    }
}
