package tests;

import static org.junit.Assert.*;

import liste.*;

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


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

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

        dieListe.einfuegenBei(2, 49);
        Tester.pruefeListenInhalt(dieListe, new int[]{21, 515, 49});

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

        dieListe.anhaengen(476);
        Tester.pruefeListenInhalt(dieListe, new int[]{21, 49, 476});

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

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

        dieListe.einfuegenBei(1, 132);
        Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 49, 476});

        dieListe.einfuegenBei(2, 854);
        Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 854, 49, 476});

        dieListe.einfuegenBei(2, 624);
        Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 624, 854, 49, 476});

        dieListe.anhaengen(470);
        Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 624, 854, 49, 476, 470});

        dieListe.einfuegenBei(1, 558);
        Tester.pruefeListenInhalt(dieListe, new int[]{927, 558, 132, 624, 854, 49, 476, 470});

        assertFalse("Fehler: Element 578 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(578));
        dieListe.einfuegenBei(0, 213);
        Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 624, 854, 49, 476, 470});

        assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701));
        dieListe.anhaengen(257);
        Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 624, 854, 49, 476, 470, 257});

        dieListe.einfuegenBei(4, 742);
        Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 742, 624, 854, 49, 476, 470, 257});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 742, 624, 854, 49, 476, 257});

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

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

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

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

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

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

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

        dieListe.einfuegenBei(3, 240);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 821, 240, 799});

        dieListe.einfuegenBei(2, 490);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 490, 821, 240, 799});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 490, 821, 799});

        dieListe.einfuegenBei(0, 880);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799});

        dieListe.anhaengen(975);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799, 975});

        dieListe.anhaengen(458);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799, 975, 458});

        assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854));
        assertTrue("Fehler: Element 799 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(799));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458});

        dieListe.anhaengen(44);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458, 44});

        dieListe.einfuegenBei(8, 748);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458, 44, 748});

        assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44));
        dieListe.einfuegenBei(6, 942);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 942, 458, 44, 748});

        dieListe.einfuegenBei(2, 844);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 844, 490, 821, 799, 975, 942, 458, 44, 748});

        dieListe.einfuegenBei(4, 89);
        Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748});

        dieListe.anhaengen(907);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748, 907});

        dieListe.einfuegenBei(4, 510);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 748, 907});

        dieListe.anhaengen(496);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 748, 907, 496});

        assertTrue("Fehler: Element 844 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(844));
        dieListe.einfuegenBei(11, 780);
        Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496});

        assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496));
        dieListe.anhaengen(142);
        Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142});

        dieListe.einfuegenBei(5, 374);
        Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142});

        dieListe.einfuegenBei(2, 887);
        Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 887, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142});

        assertFalse("Fehler: Element 704 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(704));
        dieListe.einfuegenBei(0, 534);
        Tester.pruefeListenInhalt(dieListe, new int[]{534, 844, 490, 887, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142});

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(165);
        Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895, 165});

        dieListe.einfuegenBei(4, 574);
        Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895, 165, 574});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 165, 574});

        dieListe.einfuegenBei(0, 368);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574});

        dieListe.einfuegenBei(2, 190);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 190, 562, 165, 574});

        assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574});

        dieListe.anhaengen(624);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574, 624});

        dieListe.einfuegenBei(2, 494);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 494, 562, 165, 574, 624});

        dieListe.anhaengen(330);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 494, 562, 165, 574, 624, 330});

        dieListe.einfuegenBei(2, 409);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 330});

        assertFalse("Fehler: Element 18 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(18));
        assertTrue("Fehler: Element 574 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(574));
        dieListe.einfuegenBei(8, 678);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330});

        dieListe.anhaengen(979);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979});

        dieListe.anhaengen(19);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 19});

        assertFalse("Fehler: Element 380 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(380));
        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979});

        dieListe.anhaengen(21);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21});

        dieListe.anhaengen(499);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499});

        dieListe.anhaengen(387);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499, 387});

        dieListe.einfuegenBei(1, 42);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499, 387});

        assertTrue("Fehler: Element 330 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(330));
        dieListe.einfuegenBei(13, 91);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 494, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387});

        assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387});

        dieListe.anhaengen(967);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387, 967});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 387, 967});

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

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

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

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

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

    }

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

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

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

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

        dieListe.einfuegenBei(2, 39);
        Tester.pruefeListenInhalt(dieListe, new int[]{273, 575, 39});

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 42);
        Tester.pruefeListenInhalt(dieListe, new int[]{803, 42, 792});

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

        dieListe.einfuegenBei(2, 757);
        Tester.pruefeListenInhalt(dieListe, new int[]{803, 792, 757});

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

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

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

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

        dieListe.anhaengen(632);
        Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 632});

        dieListe.einfuegenBei(3, 559);
        Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632});

        assertTrue("Fehler: Element 213 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(213));
        dieListe.anhaengen(141);
        Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632, 141});

        dieListe.anhaengen(388);
        Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632, 141, 388});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 632, 141, 388});

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

        dieListe.anhaengen(961);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 141, 388, 961});

        assertTrue("Fehler: Element 35 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(35));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 388, 961});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 388, 961});

        dieListe.anhaengen(349);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 388, 961, 349});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349});

        dieListe.anhaengen(175);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349, 175});

        dieListe.anhaengen(488);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349, 175, 488});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 175, 488});

        dieListe.anhaengen(466);
        Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 175, 488, 466});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 175, 488, 466});

        dieListe.einfuegenBei(2, 689);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 689, 175, 488, 466});

        dieListe.einfuegenBei(2, 482);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 175, 488, 466});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466});

        dieListe.anhaengen(119);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119});

        assertFalse("Fehler: Element 878 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(878));
        dieListe.anhaengen(715);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715});

        assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961));
        dieListe.anhaengen(375);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 375});

        dieListe.anhaengen(152);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 375, 152});

        assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 152});

        dieListe.anhaengen(43);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 152, 43});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 715, 152, 43});

        dieListe.einfuegenBei(6, 136);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 136, 715, 152, 43});

        dieListe.einfuegenBei(6, 16);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 16, 136, 715, 152, 43});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 136, 715, 152, 43});

        dieListe.einfuegenBei(6, 956);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 956, 136, 715, 152, 43});

        dieListe.einfuegenBei(10, 160);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 956, 136, 715, 152, 160, 43});

        dieListe.einfuegenBei(6, 482);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 136, 715, 152, 160, 43});

        dieListe.anhaengen(632);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 136, 715, 152, 160, 43, 632});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632});

        dieListe.anhaengen(809);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809});

        dieListe.anhaengen(578);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578});

        dieListe.anhaengen(604);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578, 604});

        dieListe.anhaengen(726);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578, 604, 726});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 604, 726});

        dieListe.anhaengen(273);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 604, 726, 273});

        dieListe.einfuegenBei(14, 238);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 238, 604, 726, 273});

        dieListe.einfuegenBei(18, 435);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 238, 604, 726, 273, 435});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435});

        dieListe.anhaengen(359);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 359});

        assertFalse("Fehler: Element 521 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(521));
        dieListe.anhaengen(443);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 359, 443});

        dieListe.einfuegenBei(17, 423);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 423, 359, 443});

        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443});

        assertTrue("Fehler: Element 632 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(632));
        dieListe.anhaengen(769);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443, 769});

        dieListe.anhaengen(482);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443, 769, 482});

        dieListe.einfuegenBei(11, 239);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 239, 238, 604, 726, 435, 423, 359, 443, 769, 482});

        assertTrue("Fehler: Element 769 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(769));
        dieListe.entferneBei(16);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 239, 238, 604, 726, 435, 359, 443, 769, 482});

        dieListe.einfuegenBei(10, 504);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 504, 578, 239, 238, 604, 726, 435, 359, 443, 769, 482});

        dieListe.entferneBei(16);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 504, 578, 239, 238, 604, 726, 359, 443, 769, 482});

        assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529));
        assertTrue("Fehler: Element 466 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(466));
        assertFalse("Fehler: Element 281 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(281));
        dieListe.einfuegenBei(10, 525);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769, 482});

        dieListe.entferneBei(20);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769});

        dieListe.einfuegenBei(8, 301);
        Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 301, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769});

    }

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

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

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

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

        dieListe.einfuegenBei(2, 69);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69});

        dieListe.anhaengen(577);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69, 577});

        dieListe.anhaengen(436);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69, 577, 436});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 577, 436});

        dieListe.anhaengen(260);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 577, 436, 260});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260});

        dieListe.anhaengen(541);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260, 541});

        dieListe.anhaengen(943);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260, 541, 943});

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

        dieListe.anhaengen(372);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943, 372});

        dieListe.anhaengen(846);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943, 372, 846});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 372, 846});

        dieListe.anhaengen(689);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 372, 846, 689});

        dieListe.einfuegenBei(4, 57);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 57, 372, 846, 689});

        dieListe.einfuegenBei(0, 262);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 846, 689});

        assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689});

        dieListe.anhaengen(129);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 129});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689});

        dieListe.anhaengen(437);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437});

        dieListe.anhaengen(952);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437, 952});

        dieListe.anhaengen(807);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437, 952, 807});

        dieListe.einfuegenBei(7, 72);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952, 807});

        assertFalse("Fehler: Element 886 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(886));
        assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772));
        assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72));
        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952});

        dieListe.anhaengen(709);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952, 709});

        assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262));
        dieListe.einfuegenBei(10, 821);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 821, 952, 709});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 372, 72, 689, 437, 821, 952, 709});

        dieListe.anhaengen(898);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 372, 72, 689, 437, 821, 952, 709, 898});

        assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72));
        dieListe.einfuegenBei(5, 139);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 139, 372, 72, 689, 437, 821, 952, 709, 898});

        dieListe.einfuegenBei(2, 886);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 689, 437, 821, 952, 709, 898});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 689, 821, 952, 709, 898});

        dieListe.einfuegenBei(9, 836);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 898});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 898});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709});

        assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943));
        assertFalse("Fehler: Element 237 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(237));
        dieListe.einfuegenBei(13, 803);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803});

        dieListe.anhaengen(918);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803, 918});

        assertFalse("Fehler: Element 799 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(799));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803, 918});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 821, 709, 803, 918});

        assertTrue("Fehler: Element 918 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(918));
        assertFalse("Fehler: Element 652 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(652));
        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918});

        dieListe.anhaengen(578);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578});

        dieListe.anhaengen(954);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954});

        dieListe.einfuegenBei(10, 961);
        Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 961, 803, 918, 578, 954});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 961, 803, 918, 578, 954});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954});

        dieListe.anhaengen(178);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178});

        dieListe.anhaengen(733);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178, 733});

        assertTrue("Fehler: Element 803 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(803));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178, 733});

        assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325));
        assertFalse("Fehler: Element 50 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(50));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 372, 72, 836, 689, 709, 803, 918, 954, 178, 733});

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

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

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

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

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

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

        assertFalse("Fehler: Element 72 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(72));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{242, 467, 927});

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

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

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

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

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

        dieListe.einfuegenBei(1, 308);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 308, 591});

        dieListe.einfuegenBei(1, 819);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 819, 308, 591});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 819, 308});

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

        assertTrue("Fehler: Element 111 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(111));
        dieListe.einfuegenBei(1, 680);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 308});

        assertTrue("Fehler: Element 680 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(680));
        dieListe.einfuegenBei(1, 686);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 686, 680, 225, 819, 308});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 308});

        dieListe.einfuegenBei(4, 816);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 816, 308});

        dieListe.anhaengen(124);
        Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 816, 308, 124});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{680, 225, 819, 816, 308, 124});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 124});

        dieListe.einfuegenBei(4, 19);
        Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 19, 124});

        dieListe.einfuegenBei(4, 569);
        Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 569, 19, 124});

    }

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

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

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

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

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

        dieListe.anhaengen(201);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735, 201});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735});

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

        dieListe.anhaengen(54);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54});

        assertTrue("Fehler: Element 735 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(735));
        assertTrue("Fehler: Element 474 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(474));
        dieListe.anhaengen(940);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54, 940});

        assertTrue("Fehler: Element 562 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(562));
        dieListe.einfuegenBei(5, 631);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54, 631, 940});

        assertFalse("Fehler: Element 250 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(250));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940});

        dieListe.einfuegenBei(6, 30);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 30});

        dieListe.anhaengen(966);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 30, 966});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966});

        dieListe.anhaengen(931);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966, 931});

        dieListe.anhaengen(748);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966, 931, 748});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 940, 966, 931, 748});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 735, 54, 940, 966, 931, 748});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 940, 966, 931, 748});

        dieListe.einfuegenBei(5, 214);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 940, 966, 931, 214, 748});

        dieListe.einfuegenBei(2, 28);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 931, 214, 748});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 214, 748});

        dieListe.anhaengen(397);
        Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 214, 748, 397});

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

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

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

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

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

        dieListe.anhaengen(962);
        Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 962});

        assertFalse("Fehler: Element 287 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(287));
        assertTrue("Fehler: Element 962 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(962));
        dieListe.anhaengen(581);
        Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 962, 581});

        dieListe.einfuegenBei(2, 163);
        Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 163, 962, 581});

        dieListe.einfuegenBei(1, 678);
        Tester.pruefeListenInhalt(dieListe, new int[]{480, 678, 950, 163, 962, 581});

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

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

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

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

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

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

        assertFalse("Fehler: Element 82 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(82));
        assertFalse("Fehler: Element 256 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(256));
        dieListe.einfuegenBei(0, 968);
        Tester.pruefeListenInhalt(dieListe, new int[]{968, 267});

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 771);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 771, 56, 715, 757, 844});

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

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 844});

        assertTrue("Fehler: Element 332 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(332));
        assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905));
        dieListe.einfuegenBei(4, 175);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 844, 175});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175});

        dieListe.einfuegenBei(2, 774);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 774, 757, 175});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175});

        assertTrue("Fehler: Element 56 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(56));
        dieListe.anhaengen(711);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175, 711});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 711});

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

        dieListe.einfuegenBei(1, 238);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 56, 757, 711, 980});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 980});

        dieListe.anhaengen(778);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 980, 778});

        assertTrue("Fehler: Element 980 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(980));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 778});

        dieListe.anhaengen(241);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 778, 241});

        dieListe.einfuegenBei(4, 142);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 142, 778, 241});

        assertFalse("Fehler: Element 727 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(727));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 142, 778, 241});

        dieListe.anhaengen(689);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 142, 778, 241, 689});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 778, 241, 689});

        assertTrue("Fehler: Element 238 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(238));
        dieListe.einfuegenBei(2, 843);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689});

        dieListe.anhaengen(267);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689, 267});

        assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241));
        assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412));
        assertFalse("Fehler: Element 925 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(925));
        dieListe.anhaengen(316);
        Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689, 267, 316});

        assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 778, 241, 689, 267, 316});

        assertFalse("Fehler: Element 460 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(460));
        assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950));
        assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241));
        dieListe.einfuegenBei(5, 368);
        Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 778, 241, 368, 689, 267, 316});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 241, 368, 689, 267, 316});

        assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335));
        dieListe.einfuegenBei(2, 902);
        Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 902, 711, 241, 368, 689, 267, 316});

        dieListe.anhaengen(905);
        Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 902, 711, 241, 368, 689, 267, 316, 905});

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

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

    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 586);
        Tester.pruefeListenInhalt(dieListe, new int[]{594, 586, 154});

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

        dieListe.einfuegenBei(1, 390);
        Tester.pruefeListenInhalt(dieListe, new int[]{594, 390, 154});

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

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154});

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

        dieListe.einfuegenBei(4, 249);
        Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564, 249});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564});

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

        dieListe.einfuegenBei(2, 9);
        Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564});

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

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564});

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

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

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

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 438});

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

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

        dieListe.anhaengen(732);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732});

        dieListe.anhaengen(748);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 748});

        dieListe.anhaengen(412);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 748, 412});

        assertTrue("Fehler: Element 748 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(748));
        dieListe.einfuegenBei(5, 736);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 736, 748, 412});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 438, 116, 732, 736, 748, 412});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 412});

        assertFalse("Fehler: Element 445 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(445));
        assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52));
        dieListe.anhaengen(394);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 412, 394});

        dieListe.einfuegenBei(5, 352);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 412, 394});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 394});

        dieListe.anhaengen(421);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 394, 421});

        assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179));
        assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421});

        assertFalse("Fehler: Element 629 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(629));
        dieListe.anhaengen(377);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377});

        dieListe.anhaengen(282);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377, 282});

        dieListe.anhaengen(735);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377, 282, 735});

        assertTrue("Fehler: Element 9 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(9));
        dieListe.einfuegenBei(3, 170);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 735});

        assertTrue("Fehler: Element 116 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(116));
        dieListe.anhaengen(737);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 735, 737});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737});

        dieListe.anhaengen(78);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737, 78});

        dieListe.anhaengen(71);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737, 78, 71});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 421, 377, 282, 737, 78, 71});

        dieListe.einfuegenBei(6, 369);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 737, 78, 71});

        dieListe.einfuegenBei(10, 758);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71});

        dieListe.anhaengen(364);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364});

        assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275));
        dieListe.einfuegenBei(3, 727);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364});

        dieListe.anhaengen(958);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 958});

        dieListe.einfuegenBei(16, 555);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958});

        dieListe.anhaengen(147);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958, 147});

        dieListe.anhaengen(382);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958, 147, 382});

        dieListe.entferneBei(17);
        Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 147, 382});

    }

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 994);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 994});

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

        dieListe.einfuegenBei(2, 641);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 641});

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

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

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

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

        assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765));
        dieListe.einfuegenBei(1, 106);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 97, 166});

        dieListe.einfuegenBei(6, 495);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 97, 166, 495});

        dieListe.einfuegenBei(4, 360);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 360, 97, 166, 495});

        dieListe.einfuegenBei(4, 440);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 440, 360, 97, 166, 495});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 440, 360, 97, 166, 495});

        assertFalse("Fehler: Element 195 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(195));
        dieListe.einfuegenBei(2, 652);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 652, 184, 440, 360, 97, 166, 495});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 440, 360, 97, 166, 495});

        dieListe.einfuegenBei(1, 824);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 184, 440, 360, 97, 166, 495});

        assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360));
        assertFalse("Fehler: Element 315 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(315));
        assertFalse("Fehler: Element 496 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(496));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495});

        dieListe.anhaengen(717);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495, 717});

        dieListe.anhaengen(805);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495, 717, 805});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 805});

        dieListe.anhaengen(968);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 805, 968});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 968});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 495, 717, 968});

        dieListe.einfuegenBei(6, 723);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 495, 723, 717, 968});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 495, 723, 717, 968});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 495, 723, 968});

        dieListe.einfuegenBei(2, 46);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 46, 360, 97, 495, 723, 968});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 46, 360, 97, 723, 968});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 723, 968});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 97, 723, 968});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 97, 723, 968});

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

        assertTrue("Fehler: Element 97 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(97));
        dieListe.einfuegenBei(2, 236);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 723, 236, 968});

        dieListe.einfuegenBei(0, 103);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236, 968});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236});

        dieListe.anhaengen(990);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236, 990});

        dieListe.einfuegenBei(1, 574);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990});

        dieListe.einfuegenBei(6, 626);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990, 626});

        dieListe.einfuegenBei(6, 19);
        Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990, 19, 626});

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

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

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

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

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

        dieListe.anhaengen(455);
        Tester.pruefeListenInhalt(dieListe, new int[]{830, 512, 455});

        dieListe.einfuegenBei(3, 682);
        Tester.pruefeListenInhalt(dieListe, new int[]{830, 512, 455, 682});

        assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602));
        dieListe.einfuegenBei(1, 931);
        Tester.pruefeListenInhalt(dieListe, new int[]{830, 931, 512, 455, 682});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{830, 931, 512, 682});

        dieListe.einfuegenBei(1, 566);
        Tester.pruefeListenInhalt(dieListe, new int[]{830, 566, 931, 512, 682});

        dieListe.anhaengen(349);
        Tester.pruefeListenInhalt(dieListe, new int[]{830, 566, 931, 512, 682, 349});

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

        dieListe.einfuegenBei(3, 388);
        Tester.pruefeListenInhalt(dieListe, new int[]{566, 931, 512, 388, 682, 349});

        dieListe.einfuegenBei(0, 618);
        Tester.pruefeListenInhalt(dieListe, new int[]{618, 566, 931, 512, 388, 682, 349});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{618, 566, 931, 512, 388, 682});

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

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

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

        dieListe.anhaengen(922);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 189, 922});

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

        assertFalse("Fehler: Element 490 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(490));
        assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507));
        dieListe.einfuegenBei(1, 910);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 922});

        dieListe.einfuegenBei(2, 662);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662, 922});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662});

        dieListe.einfuegenBei(1, 820);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 820, 910, 662});

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

        dieListe.anhaengen(358);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662, 358});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662});

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

        assertFalse("Fehler: Element 846 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(846));
        assertFalse("Fehler: Element 77 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(77));
        dieListe.anhaengen(473);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 662, 473});

        dieListe.anhaengen(802);
        Tester.pruefeListenInhalt(dieListe, new int[]{104, 662, 473, 802});

    }

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 93);
        Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 565, 839});

        dieListe.einfuegenBei(3, 208);
        Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 208, 565, 839});

        dieListe.einfuegenBei(1, 320);
        Tester.pruefeListenInhalt(dieListe, new int[]{136, 320, 93, 274, 208, 565, 839});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{136, 320, 93, 274, 208, 565});

        assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320));
        assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 208, 565});

        dieListe.einfuegenBei(1, 976);
        Tester.pruefeListenInhalt(dieListe, new int[]{136, 976, 93, 274, 208, 565});

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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 154);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 763, 154});

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

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

        assertFalse("Fehler: Element 975 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(975));
        dieListe.anhaengen(608);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 38, 608});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 608});

        dieListe.einfuegenBei(3, 467);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 608, 467});

        assertFalse("Fehler: Element 715 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(715));
        assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 467});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(288);
        Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288});

        dieListe.anhaengen(18);
        Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288, 18});

        dieListe.anhaengen(490);
        Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288, 18, 490});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 18, 490});

        dieListe.anhaengen(841);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 18, 490, 841});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 490, 841});

        dieListe.anhaengen(23);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 490, 841, 23});

        dieListe.einfuegenBei(3, 595);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 841, 23});

        assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490));
        dieListe.anhaengen(314);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 841, 23, 314});

        dieListe.einfuegenBei(5, 674);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 674, 841, 23, 314});

        assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490));
        assertTrue("Fehler: Element 314 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(314));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 674, 841, 23, 314});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 841, 23, 314});

        assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314});

        assertFalse("Fehler: Element 107 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(107));
        dieListe.anhaengen(858);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314, 858});

        dieListe.anhaengen(892);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314, 858, 892});

        dieListe.einfuegenBei(1, 539);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 490, 23, 314, 858, 892});

        dieListe.anhaengen(875);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 490, 23, 314, 858, 892, 875});

        dieListe.einfuegenBei(4, 64);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875});

        dieListe.anhaengen(588);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588});

        dieListe.einfuegenBei(12, 567);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588, 567});

        dieListe.anhaengen(261);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588, 567, 261});

        dieListe.einfuegenBei(10, 75);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 588, 567, 261});

        dieListe.anhaengen(528);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 588, 567, 261, 528});

        dieListe.einfuegenBei(12, 88);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 88, 588, 567, 261, 528});

        assertFalse("Fehler: Element 433 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(433));
        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528});

        dieListe.anhaengen(630);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630});

        assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490));
        dieListe.anhaengen(683);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683});

        dieListe.anhaengen(211);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211});

        assertTrue("Fehler: Element 375 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(375));
        assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588));
        assertFalse("Fehler: Element 25 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(25));
        dieListe.einfuegenBei(5, 332);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211});

        dieListe.anhaengen(414);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414});

        assertTrue("Fehler: Element 211 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(211));
        dieListe.anhaengen(449);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414, 449});

        dieListe.einfuegenBei(16, 77);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 77, 683, 211, 414, 449});

        dieListe.einfuegenBei(1, 278);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 77, 683, 211, 414, 449});

        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 630, 77, 683, 211, 414, 449});

        dieListe.anhaengen(34);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 630, 77, 683, 211, 414, 449, 34});

    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(3, 473);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473});

        dieListe.anhaengen(655);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 655});

        assertTrue("Fehler: Element 655 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(655));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473});

        dieListe.anhaengen(646);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646});

        dieListe.anhaengen(337);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646, 337});

        dieListe.einfuegenBei(5, 490);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646, 490, 337});

        assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 646, 490, 337});

        dieListe.einfuegenBei(2, 72);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 935, 646, 490, 337});

        assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490));
        assertFalse("Fehler: Element 628 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(628));
        dieListe.anhaengen(313);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 935, 646, 490, 337, 313});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313});

        dieListe.anhaengen(909);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313, 909});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313});

        dieListe.einfuegenBei(5, 331);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 331, 337, 313});

        assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485));
        dieListe.anhaengen(86);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 331, 337, 313, 86});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 72, 646, 490, 331, 337, 313, 86});

        assertTrue("Fehler: Element 121 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(121));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 490, 331, 337, 313, 86});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 337, 313, 86});

        dieListe.anhaengen(600);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 337, 313, 86, 600});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 313, 86, 600});

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

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

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

        assertFalse("Fehler: Element 304 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(304));
        dieListe.anhaengen(286);
        Tester.pruefeListenInhalt(dieListe, new int[]{437, 788, 286});

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

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

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

        dieListe.anhaengen(352);
        Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352});

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

        dieListe.anhaengen(931);
        Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 581, 931});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 931});

        assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618));
        dieListe.einfuegenBei(1, 861);
        Tester.pruefeListenInhalt(dieListe, new int[]{286, 861, 618, 352, 931});

        assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931));
        dieListe.einfuegenBei(3, 190);
        Tester.pruefeListenInhalt(dieListe, new int[]{286, 861, 618, 190, 352, 931});

        assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861));
        assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618));
        dieListe.einfuegenBei(1, 699);
        Tester.pruefeListenInhalt(dieListe, new int[]{286, 699, 861, 618, 190, 352, 931});

        dieListe.einfuegenBei(2, 935);
        Tester.pruefeListenInhalt(dieListe, new int[]{286, 699, 935, 861, 618, 190, 352, 931});

        dieListe.einfuegenBei(0, 653);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 190, 352, 931});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931});

        assertTrue("Fehler: Element 286 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(286));
        assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781));
        dieListe.einfuegenBei(8, 959);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931, 959});

        dieListe.anhaengen(337);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931, 959, 337});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 931, 959, 337});

        dieListe.einfuegenBei(4, 698);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337});

        dieListe.anhaengen(333);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333});

        assertFalse("Fehler: Element 180 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(180));
        assertFalse("Fehler: Element 702 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(702));
        assertFalse("Fehler: Element 226 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(226));
        dieListe.anhaengen(623);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623});

        assertFalse("Fehler: Element 939 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(939));
        dieListe.anhaengen(25);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623, 25});

        assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623));
        dieListe.anhaengen(595);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623, 25, 595});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595});

        dieListe.anhaengen(494);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595, 494});

        assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618));
        dieListe.anhaengen(440);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595, 494, 440});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 959, 337, 333, 623, 25, 595, 494, 440});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440});

        assertTrue("Fehler: Element 337 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(337));
        dieListe.anhaengen(838);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{653, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838});

        assertFalse("Fehler: Element 421 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(421));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838});

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(3, 536);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 942, 536});

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

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339, 536});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339});

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

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

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

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

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

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

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

        dieListe.anhaengen(592);
        Tester.pruefeListenInhalt(dieListe, new int[]{336, 417, 592});

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

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

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

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

        assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351));
        assertTrue("Fehler: Element 592 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(592));
        assertFalse("Fehler: Element 169 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(169));
        dieListe.einfuegenBei(1, 634);
        Tester.pruefeListenInhalt(dieListe, new int[]{592, 634});

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

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

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

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

        dieListe.anhaengen(785);
        Tester.pruefeListenInhalt(dieListe, new int[]{592, 866, 785});

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

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

        dieListe.anhaengen(189);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785, 189});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785});

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

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

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

        dieListe.einfuegenBei(1, 904);
        Tester.pruefeListenInhalt(dieListe, new int[]{866, 904, 923});

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

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

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

        assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778));
        assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{904, 923, 884});

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

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

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

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

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

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

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

        dieListe.anhaengen(893);
        Tester.pruefeListenInhalt(dieListe, new int[]{140, 174, 893});

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

        dieListe.anhaengen(892);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 893, 892});

        dieListe.einfuegenBei(3, 769);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 893, 892, 769});

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

        assertFalse("Fehler: Element 429 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(429));
        dieListe.anhaengen(193);
        Tester.pruefeListenInhalt(dieListe, new int[]{893, 892, 769, 193});

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

        dieListe.einfuegenBei(0, 723);
        Tester.pruefeListenInhalt(dieListe, new int[]{723, 893, 892, 769, 193, 676});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{723, 893, 892, 769, 676});

        dieListe.einfuegenBei(1, 481);
        Tester.pruefeListenInhalt(dieListe, new int[]{723, 481, 893, 892, 769, 676});

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

        dieListe.einfuegenBei(3, 637);
        Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 676});

        assertFalse("Fehler: Element 870 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(870));
        dieListe.anhaengen(477);
        Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 676, 477});

        dieListe.einfuegenBei(5, 59);
        Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 59, 676, 477});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{481, 892, 637, 769, 59, 676, 477});

        assertTrue("Fehler: Element 676 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(676));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 769, 59, 676, 477});

        dieListe.einfuegenBei(2, 540);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 769, 59, 676, 477});

        assertFalse("Fehler: Element 861 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(861));
        dieListe.einfuegenBei(7, 857);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 769, 59, 676, 477, 857});

        dieListe.einfuegenBei(3, 674);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 59, 676, 477, 857});

        assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59));
        dieListe.einfuegenBei(5, 382);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 477, 857});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 477});

        assertTrue("Fehler: Element 674 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(674));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676});

        dieListe.einfuegenBei(3, 921);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 921, 674, 769, 382, 59, 676});

        assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676});

        dieListe.einfuegenBei(8, 77);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77});

        assertTrue("Fehler: Element 769 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(769));
        dieListe.anhaengen(791);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 791});

        dieListe.einfuegenBei(10, 702);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 791, 702});

        assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553));
        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 702});

    }

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 519);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 671, 510});

        dieListe.anhaengen(460);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 671, 510, 460});

        assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149));
        dieListe.einfuegenBei(3, 676);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 676, 671, 510, 460});

        dieListe.einfuegenBei(3, 717);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 510, 460});

        dieListe.einfuegenBei(6, 941);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460});

        assertFalse("Fehler: Element 836 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(836));
        dieListe.anhaengen(470);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470});

        dieListe.anhaengen(852);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470, 852});

        assertFalse("Fehler: Element 894 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(894));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470});

        dieListe.einfuegenBei(4, 126);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 671, 941, 510, 460, 470});

        dieListe.einfuegenBei(7, 396);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 671, 396, 941, 510, 460, 470});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 470});

        dieListe.anhaengen(659);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 470, 659});

        assertFalse("Fehler: Element 588 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(588));
        dieListe.einfuegenBei(10, 398);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 398, 470, 659});

        assertTrue("Fehler: Element 398 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(398));
        dieListe.einfuegenBei(12, 366);
        Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 398, 470, 366, 659});

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(5, 21);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 808, 21});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 21});

        dieListe.einfuegenBei(2, 211);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854, 99, 21});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854, 99});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854});

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

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

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

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

        assertFalse("Fehler: Element 386 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(386));
        dieListe.einfuegenBei(0, 831);
        Tester.pruefeListenInhalt(dieListe, new int[]{831, 854, 922});

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

        dieListe.einfuegenBei(0, 370);
        Tester.pruefeListenInhalt(dieListe, new int[]{370, 831, 252, 854, 922});

        assertFalse("Fehler: Element 492 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(492));
        assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{370, 252, 854, 922});

        assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718));
        dieListe.anhaengen(395);
        Tester.pruefeListenInhalt(dieListe, new int[]{370, 252, 854, 922, 395});

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

        dieListe.einfuegenBei(4, 207);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207});

        dieListe.anhaengen(974);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974});

        dieListe.anhaengen(290);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290});

        dieListe.einfuegenBei(3, 915);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290});

        dieListe.einfuegenBei(7, 784);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 784, 290});

        assertFalse("Fehler: Element 870 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(870));
        assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290));
        dieListe.anhaengen(708);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 784, 290, 708});

        assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290, 708});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290});

        dieListe.anhaengen(722);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290, 722});

        dieListe.anhaengen(663);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290, 722, 663});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 722, 663});

        dieListe.anhaengen(746);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 722, 663, 746});

        dieListe.einfuegenBei(6, 377);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746});

        assertTrue("Fehler: Element 974 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(974));
        dieListe.anhaengen(271);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271});

        dieListe.anhaengen(708);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271, 708});

        assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271));
        dieListe.einfuegenBei(11, 974);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271, 974, 708});

        dieListe.einfuegenBei(8, 426);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 426, 663, 746, 271, 974, 708});

        assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 746, 271, 974, 708});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 271, 974, 708});

        dieListe.einfuegenBei(9, 132);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708});

        dieListe.einfuegenBei(13, 666);
        Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666});

        assertTrue("Fehler: Element 252 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(252));
        dieListe.einfuegenBei(0, 717);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666});

        assertTrue("Fehler: Element 426 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(426));
        assertTrue("Fehler: Element 974 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(974));
        dieListe.anhaengen(659);
        Tester.pruefeListenInhalt(dieListe, new int[]{717, 252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666, 659});

    }
}
