package tests;

import static org.junit.Assert.*;

import liste.*;

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


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

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

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

        assertFalse("Fehler: Element 586 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(586));
        dieListe.anhaengen(920);
        Tester.pruefeListenInhalt(dieListe, new int[]{651, 576, 763, 920});

        dieListe.einfuegenBei(0, 418);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 651, 576, 763, 920});

        dieListe.anhaengen(781);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 651, 576, 763, 920, 781});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 576, 763, 920, 781});

        dieListe.anhaengen(304);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 576, 763, 920, 781, 304});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 920, 781, 304});

        assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304));
        assertFalse("Fehler: Element 468 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(468));
        assertTrue("Fehler: Element 781 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(781));
        dieListe.einfuegenBei(0, 223);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 304});

        assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24));
        dieListe.anhaengen(939);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 304, 939});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 939});

        dieListe.einfuegenBei(4, 685);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939});

        dieListe.anhaengen(475);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939, 475});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939});

        assertTrue("Fehler: Element 418 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(418));
        dieListe.einfuegenBei(7, 598);
        Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939, 598});

        assertFalse("Fehler: Element 843 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(843));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 920, 685, 781, 939, 598});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 685, 781, 939, 598});

        dieListe.anhaengen(402);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 685, 781, 939, 598, 402});

        dieListe.einfuegenBei(1, 36);
        Tester.pruefeListenInhalt(dieListe, new int[]{418, 36, 763, 685, 781, 939, 598, 402});

        dieListe.einfuegenBei(0, 13);
        Tester.pruefeListenInhalt(dieListe, new int[]{13, 418, 36, 763, 685, 781, 939, 598, 402});

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

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

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

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

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

        dieListe.einfuegenBei(2, 963);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963});

        dieListe.anhaengen(419);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963, 419});

        assertTrue("Fehler: Element 862 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(862));
        dieListe.einfuegenBei(4, 371);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963, 419, 371});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 419, 371});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371});

        assertFalse("Fehler: Element 609 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(609));
        dieListe.anhaengen(641);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371, 641});

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

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

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

        assertFalse("Fehler: Element 187 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(187));
        assertTrue("Fehler: Element 952 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(952));
        dieListe.anhaengen(133);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133});

        assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371));
        dieListe.anhaengen(958);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133, 958});

        dieListe.anhaengen(20);
        Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133, 958, 20});

        assertFalse("Fehler: Element 422 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(422));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{371, 952, 133, 958, 20});

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

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

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

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

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

        assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968));
        assertFalse("Fehler: Element 803 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(803));
        assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968));
        dieListe.anhaengen(74);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 968, 74});

        dieListe.einfuegenBei(3, 682);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 682, 968, 74});

        assertTrue("Fehler: Element 772 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(772));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74});

        assertTrue("Fehler: Element 105 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(105));
        dieListe.einfuegenBei(2, 614);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 614, 682, 968, 74});

        dieListe.einfuegenBei(0, 525);
        Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74});

        assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503));
        assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968));
        dieListe.anhaengen(878);
        Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74, 878});

        dieListe.einfuegenBei(8, 185);
        Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74, 878, 185});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 682, 968, 74, 878, 185});

        assertTrue("Fehler: Element 878 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(878));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74, 878, 185});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74, 185});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 74, 185});

        assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313));
        assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968));
        dieListe.anhaengen(97);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 74, 185, 97});

        dieListe.einfuegenBei(3, 177);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 185, 97});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 97});

        dieListe.anhaengen(816);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 97, 816});

        assertTrue("Fehler: Element 105 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(105));
        dieListe.einfuegenBei(5, 180);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 180, 97, 816});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 180, 816});

        assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475));
        dieListe.einfuegenBei(4, 40);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816});

        assertFalse("Fehler: Element 849 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(849));
        dieListe.anhaengen(910);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816, 910});

        dieListe.anhaengen(679);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816, 910, 679});

        assertFalse("Fehler: Element 295 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(295));
        dieListe.einfuegenBei(4, 739);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 739, 40, 74, 180, 816, 910, 679});

        dieListe.anhaengen(773);
        Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 739, 40, 74, 180, 816, 910, 679, 773});

    }

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

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

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

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

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

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

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

        dieListe.anhaengen(79);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79});

        dieListe.anhaengen(266);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266});

        dieListe.anhaengen(535);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266, 535});

        dieListe.einfuegenBei(6, 522);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 522, 266, 535});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266, 535});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 535});

        dieListe.anhaengen(496);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 535, 496});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496});

        dieListe.anhaengen(192);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192});

        dieListe.anhaengen(723);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192, 723});

        dieListe.anhaengen(299);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192, 723, 299});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 496, 192, 723, 299});

        assertTrue("Fehler: Element 299 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(299));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 496, 192, 299});

        assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407));
        dieListe.einfuegenBei(5, 143);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 143, 496, 192, 299});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 143, 496, 192});

        dieListe.einfuegenBei(4, 126);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 126, 266, 143, 496, 192});

        dieListe.einfuegenBei(7, 374);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 126, 266, 143, 374, 496, 192});

        dieListe.einfuegenBei(2, 47);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 154, 79, 126, 266, 143, 374, 496, 192});

        dieListe.einfuegenBei(8, 686);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 154, 79, 126, 266, 143, 686, 374, 496, 192});

        dieListe.einfuegenBei(3, 607);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192});

        dieListe.einfuegenBei(3, 599);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 599, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192});

        assertTrue("Fehler: Element 686 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(686));
        dieListe.einfuegenBei(3, 216);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 266, 143, 686, 374, 496, 192});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 266, 143, 374, 496, 192});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 374, 496, 192});

        dieListe.einfuegenBei(10, 865);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 374, 496, 865, 192});

        assertTrue("Fehler: Element 607 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(607));
        assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914));
        dieListe.einfuegenBei(8, 444);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192});

        dieListe.anhaengen(137);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192, 137});

        dieListe.anhaengen(349);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192, 137, 349});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349});

        assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914));
        assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156));
        assertTrue("Fehler: Element 349 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(349));
        dieListe.anhaengen(318);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318});

        dieListe.anhaengen(700);
        Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318, 700});

        assertTrue("Fehler: Element 444 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(444));
        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318, 700});

        assertTrue("Fehler: Element 216 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(216));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 154, 126, 143, 444, 496, 865, 137, 349, 318, 700});

        assertFalse("Fehler: Element 597 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(597));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 126, 143, 444, 496, 865, 137, 349, 318, 700});

        dieListe.einfuegenBei(10, 414);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 126, 143, 444, 496, 865, 137, 414, 349, 318, 700});

        assertFalse("Fehler: Element 188 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(188));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 414, 349, 318, 700});

        assertFalse("Fehler: Element 175 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(175));
        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 414, 349, 700});

        dieListe.einfuegenBei(9, 515);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 515, 414, 349, 700});

        dieListe.einfuegenBei(7, 768);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 768, 865, 137, 515, 414, 349, 700});

        dieListe.einfuegenBei(7, 82);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 82, 768, 865, 137, 515, 414, 349, 700});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 82, 768, 865, 515, 414, 349, 700});

        dieListe.einfuegenBei(4, 443);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 82, 768, 865, 515, 414, 349, 700});

        dieListe.einfuegenBei(8, 713);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700});

        dieListe.einfuegenBei(3, 311);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700});

        assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553));
        dieListe.anhaengen(503);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700, 503});

        dieListe.anhaengen(665);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700, 503, 665});

        dieListe.einfuegenBei(14, 923);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 700, 503, 665});

        assertFalse("Fehler: Element 274 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(274));
        assertTrue("Fehler: Element 713 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(713));
        assertFalse("Fehler: Element 138 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(138));
        dieListe.anhaengen(518);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 700, 503, 665, 518});

        dieListe.entferneBei(17);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518});

        dieListe.anhaengen(758);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518, 758});

        dieListe.entferneBei(14);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 758});

        assertFalse("Fehler: Element 662 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(662));
        dieListe.anhaengen(578);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 758, 578});

        dieListe.einfuegenBei(18, 349);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578});

        dieListe.einfuegenBei(11, 961);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578});

        dieListe.anhaengen(166);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166});

        assertFalse("Fehler: Element 776 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(776));
        dieListe.einfuegenBei(8, 665);
        Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 713, 665, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166});

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 798);
        Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 798, 962});

        assertFalse("Fehler: Element 327 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(327));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 798});

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(365);
        Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60, 365});

        dieListe.einfuegenBei(1, 45);
        Tester.pruefeListenInhalt(dieListe, new int[]{118, 45, 665, 998, 60, 365});

        dieListe.anhaengen(275);
        Tester.pruefeListenInhalt(dieListe, new int[]{118, 45, 665, 998, 60, 365, 275});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60, 365, 275});

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

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

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

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

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 263 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(263));
        assertFalse("Fehler: Element 448 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(448));
        assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95));
        dieListe.einfuegenBei(1, 684);
        Tester.pruefeListenInhalt(dieListe, new int[]{570, 684});

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

        dieListe.einfuegenBei(1, 478);
        Tester.pruefeListenInhalt(dieListe, new int[]{570, 478, 684, 264});

        dieListe.einfuegenBei(1, 300);
        Tester.pruefeListenInhalt(dieListe, new int[]{570, 300, 478, 684, 264});

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

        assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300));
        assertTrue("Fehler: Element 684 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(684));
        assertTrue("Fehler: Element 478 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(478));
        dieListe.anhaengen(308);
        Tester.pruefeListenInhalt(dieListe, new int[]{300, 478, 684, 264, 308});

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

        assertTrue("Fehler: Element 684 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(684));
        dieListe.einfuegenBei(4, 743);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 264, 308, 743});

        assertFalse("Fehler: Element 825 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(825));
        dieListe.einfuegenBei(2, 721);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 721, 264, 308, 743});

        dieListe.einfuegenBei(2, 688);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 721, 264, 308, 743});

        dieListe.einfuegenBei(4, 214);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 721, 214, 264, 308, 743});

        dieListe.einfuegenBei(3, 144);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 214, 264, 308, 743});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 743});

        dieListe.einfuegenBei(7, 845);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743});

        dieListe.anhaengen(371);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743, 371});

        dieListe.anhaengen(606);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743, 371, 606});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 371, 606});

        assertFalse("Fehler: Element 196 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(196));
        assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845));
        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 606});

        assertTrue("Fehler: Element 721 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(721));
        dieListe.anhaengen(817);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 606, 817});

        dieListe.einfuegenBei(7, 575);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 606, 817});

        assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364));
        assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845));
        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 606});

        dieListe.einfuegenBei(9, 704);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 704, 606});

        dieListe.einfuegenBei(9, 587);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 587, 704, 606});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 721, 264, 308, 575, 845, 587, 704, 606});

        assertFalse("Fehler: Element 910 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(910));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 264, 308, 575, 845, 587, 704, 606});

        dieListe.einfuegenBei(10, 871);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871});

        assertTrue("Fehler: Element 704 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(704));
        dieListe.einfuegenBei(1, 600);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 600, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871});

        dieListe.einfuegenBei(1, 910);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 600, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 600, 688, 144, 264, 308, 575, 587, 704, 606, 871});

        dieListe.einfuegenBei(2, 326);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 600, 688, 144, 264, 308, 575, 587, 704, 606, 871});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 144, 264, 308, 575, 587, 704, 606, 871});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871});

        dieListe.anhaengen(866);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871, 866});

        dieListe.anhaengen(406);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871, 866, 406});

        dieListe.entferneBei(10);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406});

        dieListe.anhaengen(954);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954});

        dieListe.einfuegenBei(2, 916);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954});

        dieListe.anhaengen(483);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954, 483});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483});

        assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477));
        dieListe.anhaengen(280);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483, 280});

        assertFalse("Fehler: Element 307 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(307));
        dieListe.anhaengen(424);
        Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483, 280, 424});

    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(348);
        Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 220, 348});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 348});

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 496);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225});

        assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225));
        dieListe.anhaengen(693);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 693});

        dieListe.einfuegenBei(4, 543);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 543, 693});

        dieListe.anhaengen(718);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 543, 693, 718});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225, 543, 693, 718});

        dieListe.anhaengen(896);
        Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225, 543, 693, 718, 896});

        assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225));
        dieListe.einfuegenBei(0, 159);
        Tester.pruefeListenInhalt(dieListe, new int[]{159, 304, 944, 225, 543, 693, 718, 896});

        dieListe.einfuegenBei(4, 199);
        Tester.pruefeListenInhalt(dieListe, new int[]{159, 304, 944, 225, 199, 543, 693, 718, 896});

        assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304));
        assertTrue("Fehler: Element 896 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(896));
        dieListe.einfuegenBei(0, 317);
        Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896});

        dieListe.anhaengen(858);
        Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858});

        dieListe.anhaengen(581);
        Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858, 581});

        dieListe.einfuegenBei(0, 97);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858, 581});

        dieListe.einfuegenBei(4, 667);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 858, 581});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 581});

        dieListe.anhaengen(267);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 581, 267});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267});

        dieListe.anhaengen(368);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267, 368});

        dieListe.anhaengen(245);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267, 368, 245});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245});

        dieListe.anhaengen(371);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245, 371});

        assertFalse("Fehler: Element 828 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(828));
        dieListe.einfuegenBei(2, 919);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245, 371});

        dieListe.entferneBei(14);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371});

        dieListe.einfuegenBei(3, 272);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371});

        dieListe.anhaengen(718);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718});

        dieListe.anhaengen(568);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568});

        assertFalse("Fehler: Element 287 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(287));
        dieListe.einfuegenBei(3, 874);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 874, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568});

        dieListe.anhaengen(810);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810});

        assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267));
        assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368));
        dieListe.anhaengen(65);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65});

        dieListe.anhaengen(234);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65, 234});

        dieListe.anhaengen(285);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65, 234, 285});

        dieListe.einfuegenBei(17, 501);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285});

        dieListe.einfuegenBei(7, 818);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 818, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285});

        assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718));
        dieListe.anhaengen(277);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277});

        dieListe.anhaengen(319);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319});

        dieListe.anhaengen(190);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190});

        dieListe.einfuegenBei(2, 631);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 631, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190});

        dieListe.einfuegenBei(13, 516);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 631, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190});

        assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190});

        dieListe.entferneBei(21);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190});

        dieListe.anhaengen(446);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446});

        dieListe.anhaengen(922);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922});

        dieListe.anhaengen(442);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442});

        assertTrue("Fehler: Element 818 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(818));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442});

        dieListe.entferneBei(13);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442});

        dieListe.anhaengen(351);
        Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442, 351});

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(332);
        Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 332});

        assertTrue("Fehler: Element 873 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(873));
        assertFalse("Fehler: Element 519 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(519));
        dieListe.einfuegenBei(2, 79);
        Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 79, 332});

        dieListe.anhaengen(482);
        Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 79, 332, 482});

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 966);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 966, 568});

        dieListe.einfuegenBei(1, 131);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568});

        dieListe.anhaengen(863);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568, 863});

        assertFalse("Fehler: Element 774 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(774));
        dieListe.anhaengen(123);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568, 863, 123});

        dieListe.einfuegenBei(2, 480);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 966, 568, 863, 123});

        assertFalse("Fehler: Element 873 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(873));
        assertFalse("Fehler: Element 528 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(528));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 568, 863, 123});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 123});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863});

        dieListe.anhaengen(416);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416});

        dieListe.anhaengen(257);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416, 257});

        dieListe.anhaengen(823);
        Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416, 257, 823});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        assertTrue("Fehler: Element 236 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(236));
        dieListe.einfuegenBei(3, 278);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278});

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

        dieListe.anhaengen(154);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278, 21, 154});

        dieListe.einfuegenBei(3, 719);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 719, 278, 21, 154});

        dieListe.einfuegenBei(7, 599);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 719, 278, 21, 154, 599});

        assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21));
        assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 719, 278, 21, 154, 599});

        dieListe.einfuegenBei(2, 605);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 605, 719, 278, 21, 154, 599});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599});

        dieListe.anhaengen(75);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75});

        assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155));
        assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719));
        dieListe.anhaengen(528);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528});

        dieListe.anhaengen(138);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528, 138});

        dieListe.anhaengen(340);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528, 138, 340});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340});

        dieListe.anhaengen(744);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340, 744});

        assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449));
        dieListe.anhaengen(719);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340, 744, 719});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 340, 744, 719});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 340, 719});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 719});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 75, 138, 719});

        dieListe.einfuegenBei(7, 445);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 75, 138, 445, 719});

        dieListe.einfuegenBei(5, 845);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 445, 719});

        dieListe.anhaengen(333);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 445, 719, 333});

        dieListe.entferneBei(8);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333});

        dieListe.einfuegenBei(2, 536);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 536, 719, 21, 599, 845, 75, 138, 719, 333});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333});

        assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599));
        dieListe.anhaengen(733);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333, 733});

        dieListe.anhaengen(861);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333, 733, 861});

        dieListe.einfuegenBei(6, 878);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861});

        dieListe.einfuegenBei(1, 889);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861});

        dieListe.anhaengen(939);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939});

        assertFalse("Fehler: Element 667 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(667));
        dieListe.einfuegenBei(2, 741);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939});

        dieListe.anhaengen(664);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664});

        dieListe.anhaengen(344);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344});

        dieListe.einfuegenBei(18, 976);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976});

        dieListe.anhaengen(896);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896});

        dieListe.einfuegenBei(4, 794);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896});

        dieListe.einfuegenBei(8, 209);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896});

        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 861, 939, 664, 344, 976, 896});

        dieListe.einfuegenBei(2, 35);
        Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 35, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 861, 939, 664, 344, 976, 896});

    }

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

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

        dieListe.anhaengen(276);
        Tester.pruefeListenInhalt(dieListe, new int[]{760, 924, 276});

        dieListe.einfuegenBei(1, 920);
        Tester.pruefeListenInhalt(dieListe, new int[]{760, 920, 924, 276});

        dieListe.einfuegenBei(1, 574);
        Tester.pruefeListenInhalt(dieListe, new int[]{760, 574, 920, 924, 276});

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

        dieListe.anhaengen(528);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528});

        dieListe.anhaengen(900);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900});

        dieListe.anhaengen(211);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211});

        dieListe.anhaengen(189);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211, 189});

        dieListe.anhaengen(328);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211, 189, 328});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 924, 276, 528, 900, 211, 189, 328});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 924, 276, 900, 211, 189, 328});

        dieListe.einfuegenBei(1, 457);
        Tester.pruefeListenInhalt(dieListe, new int[]{574, 457, 924, 276, 900, 211, 189, 328});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 924, 276, 900, 211, 189, 328});

        dieListe.einfuegenBei(7, 459);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 924, 276, 900, 211, 189, 328, 459});

        dieListe.einfuegenBei(1, 777);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 924, 276, 900, 211, 189, 328, 459});

        assertFalse("Fehler: Element 59 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(59));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 924, 900, 211, 189, 328, 459});

        assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 900, 211, 189, 328, 459});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 900, 211, 189, 328, 459});

        dieListe.einfuegenBei(1, 319);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 328, 459});

        dieListe.anhaengen(477);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 328, 459, 477});

        dieListe.einfuegenBei(5, 955);
        Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 955, 328, 459, 477});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 211, 189, 955, 328, 459, 477});

        assertTrue("Fehler: Element 319 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(319));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 211, 189, 955, 328, 477});

        assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955));
        assertFalse("Fehler: Element 839 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(839));
        assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985));
        dieListe.einfuegenBei(2, 771);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 771, 211, 189, 955, 328, 477});

        assertFalse("Fehler: Element 848 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(848));
        dieListe.einfuegenBei(2, 421);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 421, 771, 211, 189, 955, 328, 477});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 421, 771, 211, 189, 955, 328, 477});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477});

        assertTrue("Fehler: Element 328 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(328));
        dieListe.anhaengen(852);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 852});

        dieListe.anhaengen(131);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 852, 131});

        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 131});

        dieListe.anhaengen(506);
        Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 131, 506});

        dieListe.einfuegenBei(0, 59);
        Tester.pruefeListenInhalt(dieListe, new int[]{59, 319, 771, 211, 189, 955, 328, 477, 131, 506});

        dieListe.anhaengen(824);
        Tester.pruefeListenInhalt(dieListe, new int[]{59, 319, 771, 211, 189, 955, 328, 477, 131, 506, 824});

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

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

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

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

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

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

        assertFalse("Fehler: Element 472 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(472));
        assertFalse("Fehler: Element 603 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(603));
        dieListe.anhaengen(394);
        Tester.pruefeListenInhalt(dieListe, new int[]{470, 394});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        assertTrue("Fehler: Element 885 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(885));
        assertFalse("Fehler: Element 436 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(436));
        dieListe.einfuegenBei(2, 174);
        Tester.pruefeListenInhalt(dieListe, new int[]{885, 526, 174});

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

        dieListe.einfuegenBei(2, 17);
        Tester.pruefeListenInhalt(dieListe, new int[]{526, 174, 17});

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

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

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

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

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17, 920});

        dieListe.einfuegenBei(1, 518);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 17, 920});

        dieListe.einfuegenBei(3, 685);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920});

        dieListe.anhaengen(396);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920, 396});

        dieListe.anhaengen(763);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920, 396, 763});

        assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950));
        dieListe.einfuegenBei(3, 548);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 17, 920, 396, 763});

        assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275));
        dieListe.anhaengen(604);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 17, 920, 396, 763, 604});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 920, 396, 763, 604});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 920, 396, 763, 604});

        dieListe.einfuegenBei(2, 345);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 685, 920, 396, 763, 604});

        dieListe.anhaengen(751);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 685, 920, 396, 763, 604, 751});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 920, 396, 763, 604, 751});

        assertTrue("Fehler: Element 604 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(604));
        assertFalse("Fehler: Element 953 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(953));
        assertFalse("Fehler: Element 812 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(812));
        dieListe.anhaengen(136);
        Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 920, 396, 763, 604, 751, 136});

    }

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 58);
        Tester.pruefeListenInhalt(dieListe, new int[]{455, 58, 286});

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

        dieListe.einfuegenBei(4, 496);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 455, 58, 286, 496});

        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 58, 286, 496});

        assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496));
        dieListe.einfuegenBei(1, 162);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 58, 286, 496});

        dieListe.einfuegenBei(2, 195);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 58, 286, 496});

        assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496));
        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 286, 496});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496});

        dieListe.anhaengen(911);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496, 911});

        dieListe.anhaengen(986);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496, 911, 986});

        dieListe.einfuegenBei(3, 102);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 496, 911, 986});

        assertFalse("Fehler: Element 979 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(979));
        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 496, 911});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 911});

        dieListe.anhaengen(858);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 911, 858});

        dieListe.einfuegenBei(4, 413);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 911, 858});

        dieListe.anhaengen(102);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 911, 858, 102});

        dieListe.einfuegenBei(5, 998);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 998, 911, 858, 102});

        dieListe.einfuegenBei(5, 323);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 858, 102});

        assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413));
        dieListe.einfuegenBei(8, 721);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 858, 102});

        dieListe.anhaengen(272);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 858, 102, 272});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 102, 272});

        dieListe.anhaengen(868);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 102, 272, 868});

        assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20));
        dieListe.einfuegenBei(7, 8);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 8, 911, 721, 102, 272, 868});

        dieListe.einfuegenBei(10, 757);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868});

        dieListe.einfuegenBei(1, 375);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868});

        dieListe.einfuegenBei(9, 216);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868});

        dieListe.anhaengen(692);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868, 692});

        dieListe.anhaengen(875);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875});

        dieListe.einfuegenBei(7, 132);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875});

        assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297));
        assertTrue("Fehler: Element 911 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(911));
        dieListe.einfuegenBei(18, 702);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702});

        assertTrue("Fehler: Element 692 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(692));
        dieListe.einfuegenBei(19, 707);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707});

        dieListe.anhaengen(57);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707, 57});

        dieListe.anhaengen(896);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707, 57, 896});

        assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198));
        assertFalse("Fehler: Element 770 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(770));
        dieListe.einfuegenBei(18, 643);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896});

        assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102));
        dieListe.anhaengen(397);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397});

        assertTrue("Fehler: Element 643 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(643));
        dieListe.anhaengen(85);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85});

        dieListe.einfuegenBei(5, 794);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 794, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85});

        dieListe.einfuegenBei(2, 647);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85});

        dieListe.entferneBei(12);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85});

        dieListe.einfuegenBei(1, 70);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85});

        assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102));
        dieListe.anhaengen(397);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85, 397});

        dieListe.entferneBei(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397});

        dieListe.anhaengen(491);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397, 491});

        dieListe.anhaengen(418);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397, 491, 418});

        dieListe.entferneBei(19);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 85, 397, 491, 418});

        assertFalse("Fehler: Element 177 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(177));
        assertFalse("Fehler: Element 45 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(45));
        assertFalse("Fehler: Element 310 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(310));
        dieListe.entferneBei(21);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418});

        assertFalse("Fehler: Element 73 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(73));
        dieListe.anhaengen(30);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30});

        dieListe.einfuegenBei(7, 226);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30});

        assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155));
        assertFalse("Fehler: Element 395 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(395));
        dieListe.anhaengen(913);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30, 913});

        dieListe.anhaengen(885);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30, 913, 885});

        dieListe.einfuegenBei(18, 647);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 397, 491, 418, 30, 913, 885});

        dieListe.entferneBei(23);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885});

        dieListe.einfuegenBei(11, 448);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885});

        dieListe.anhaengen(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885, 2});

        dieListe.entferneBei(25);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        dieListe.einfuegenBei(12, 390);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 8, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        dieListe.einfuegenBei(19, 133);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        dieListe.entferneBei(11);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        dieListe.einfuegenBei(15, 611);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        assertFalse("Fehler: Element 902 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(902));
        dieListe.einfuegenBei(2, 327);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 327, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2});

        assertFalse("Fehler: Element 366 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(366));
        dieListe.entferneBei(7);
        Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 327, 647, 413, 323, 998, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2});

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

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

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 980 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(980));
        dieListe.einfuegenBei(0, 472);
        Tester.pruefeListenInhalt(dieListe, new int[]{472, 894, 996, 557});

        dieListe.einfuegenBei(1, 546);
        Tester.pruefeListenInhalt(dieListe, new int[]{472, 546, 894, 996, 557});

        assertFalse("Fehler: Element 788 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(788));
        assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557));
        dieListe.einfuegenBei(0, 31);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 472, 546, 894, 996, 557});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 472, 546, 894, 996});

        assertTrue("Fehler: Element 894 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(894));
        assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978));
        dieListe.entferneBei(1);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 546, 894, 996});

        assertTrue("Fehler: Element 996 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(996));
        dieListe.einfuegenBei(2, 518);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 546, 518, 894, 996});

        dieListe.einfuegenBei(1, 555);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 894, 996});

        dieListe.anhaengen(276);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 894, 996, 276});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 996, 276});

        dieListe.einfuegenBei(2, 388);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 996, 276});

        dieListe.anhaengen(897);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 996, 276, 897});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 276, 897});

        dieListe.anhaengen(626);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 276, 897, 626});

        assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897));
        assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388));
        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626});

        assertFalse("Fehler: Element 92 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(92));
        dieListe.anhaengen(45);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45});

        dieListe.anhaengen(307);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45, 307});

        dieListe.anhaengen(479);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45, 307, 479});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 626, 45, 307, 479});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479});

        dieListe.anhaengen(712);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479, 712});

        dieListe.einfuegenBei(8, 766);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479, 766, 712});

        dieListe.entferneBei(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 479, 766, 712});

        assertTrue("Fehler: Element 555 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(555));
        dieListe.einfuegenBei(3, 878);
        Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 878, 546, 897, 45, 479, 766, 712});

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(251);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 116, 247, 338, 251});

        assertFalse("Fehler: Element 67 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(67));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 247, 338, 251});

        dieListe.einfuegenBei(1, 686);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338, 251});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338});

        assertTrue("Fehler: Element 966 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(966));
        dieListe.anhaengen(740);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338, 740});

        dieListe.einfuegenBei(2, 423);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 747, 247, 338, 740});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 247, 338, 740});

        assertFalse("Fehler: Element 272 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(272));
        assertTrue("Fehler: Element 740 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(740));
        dieListe.anhaengen(308);
        Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 247, 338, 740, 308});

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

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

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 797 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(797));
        assertTrue("Fehler: Element 456 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(456));
        dieListe.einfuegenBei(0, 729);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 415, 259, 456});

        dieListe.einfuegenBei(1, 985);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 985, 415, 259, 456});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 985, 415, 456});

        dieListe.einfuegenBei(1, 233);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 985, 415, 456});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456});

        dieListe.einfuegenBei(4, 825);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456, 825});

        dieListe.einfuegenBei(4, 651);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456, 651, 825});

        dieListe.einfuegenBei(1, 733);
        Tester.pruefeListenInhalt(dieListe, new int[]{729, 733, 233, 415, 456, 651, 825});

    }

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 745 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(745));
        dieListe.einfuegenBei(2, 633);
        Tester.pruefeListenInhalt(dieListe, new int[]{84, 949, 633});

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

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

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

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

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

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

        dieListe.einfuegenBei(3, 823);
        Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959, 823});

        assertTrue("Fehler: Element 823 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(823));
        assertFalse("Fehler: Element 975 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(975));
        dieListe.anhaengen(945);
        Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959, 823, 945});

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(167);
        Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 167});

        dieListe.einfuegenBei(2, 5);
        Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 5, 167});

        assertFalse("Fehler: Element 252 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(252));
        assertTrue("Fehler: Element 381 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(381));
        dieListe.einfuegenBei(2, 484);
        Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 484, 5, 167});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 484, 5});

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

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

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

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

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{484, 719, 5});

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

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

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

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

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

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

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

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

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

        assertFalse("Fehler: Element 386 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(386));
        dieListe.anhaengen(992);
        Tester.pruefeListenInhalt(dieListe, new int[]{952, 369, 182, 516, 992});

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(1, 179);
        Tester.pruefeListenInhalt(dieListe, new int[]{757, 179, 517});

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

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{757, 129, 179});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.einfuegenBei(2, 880);
        Tester.pruefeListenInhalt(dieListe, new int[]{713, 189, 880});

    }

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

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

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

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

        dieListe.einfuegenBei(2, 91);
        Tester.pruefeListenInhalt(dieListe, new int[]{432, 819, 91});

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

        assertFalse("Fehler: Element 612 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(612));
        dieListe.einfuegenBei(2, 346);
        Tester.pruefeListenInhalt(dieListe, new int[]{819, 91, 346});

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

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

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

        dieListe.einfuegenBei(3, 230);
        Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 230, 697});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 230});

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

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

        dieListe.einfuegenBei(1, 15);
        Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 230});

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

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

        dieListe.einfuegenBei(2, 405);
        Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 230});

        dieListe.anhaengen(497);
        Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 230, 497});

        dieListe.entferneBei(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497});

        dieListe.anhaengen(919);
        Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497, 919});

        dieListe.anhaengen(108);
        Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497, 919, 108});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 405, 497, 919, 108});

        dieListe.einfuegenBei(1, 197);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 497, 919, 108});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 497, 108});

        dieListe.einfuegenBei(3, 538);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 538, 497, 108});

        dieListe.einfuegenBei(1, 875);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108});

        assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486));
        dieListe.anhaengen(896);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108, 896});

        assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15));
        dieListe.anhaengen(786);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108, 896, 786});

        assertFalse("Fehler: Element 816 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(816));
        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 108, 896, 786});

        assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622));
        assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15));
        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 405, 538, 108, 896, 786});

        dieListe.anhaengen(512);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 405, 538, 108, 896, 786, 512});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 538, 108, 896, 786, 512});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        dieListe.anhaengen(168);
        Tester.pruefeListenInhalt(dieListe, new int[]{126, 864, 168});

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

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

        assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194));
        dieListe.einfuegenBei(3, 113);
        Tester.pruefeListenInhalt(dieListe, new int[]{126, 168, 194, 113});

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

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

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

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

        dieListe.einfuegenBei(3, 730);
        Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 730, 927});

        assertFalse("Fehler: Element 103 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(103));
        dieListe.anhaengen(355);
        Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 730, 927, 355});

        dieListe.entferneBei(0);
        Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355});

        assertTrue("Fehler: Element 730 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(730));
        dieListe.anhaengen(365);
        Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365});

        dieListe.anhaengen(29);
        Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29});

        dieListe.anhaengen(869);
        Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29, 869});

        dieListe.anhaengen(246);
        Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29, 869, 246});

        dieListe.einfuegenBei(4, 508);
        Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 508, 355, 365, 29, 869, 246});

        dieListe.einfuegenBei(0, 415);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 110, 730, 927, 508, 355, 365, 29, 869, 246});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 869, 246});

        dieListe.einfuegenBei(8, 506);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246});

        dieListe.anhaengen(862);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246, 862});

        dieListe.einfuegenBei(11, 299);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246, 299, 862});

        dieListe.entferneBei(4);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 355, 365, 29, 506, 869, 246, 299, 862});

        assertFalse("Fehler: Element 559 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(559));
        dieListe.einfuegenBei(4, 59);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 59, 355, 365, 29, 506, 869, 246, 299, 862});

        dieListe.entferneBei(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862});

        assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419));
        dieListe.einfuegenBei(1, 531);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862});

        dieListe.einfuegenBei(5, 499);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 499, 59, 355, 365, 29, 506, 246, 299, 862});

        dieListe.entferneBei(5);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862});

        dieListe.entferneBei(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862});

        assertTrue("Fehler: Element 927 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(927));
        assertFalse("Fehler: Element 221 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(221));
        assertTrue("Fehler: Element 29 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(29));
    }
}
