package tests;

import static org.junit.Assert.*;

import liste.*;

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


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

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

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

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

        assertTrue("Fehler: Element 753 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(753));
        assertTrue("Fehler: Element 753 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(753));
        dieListe.anhaengen(564);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564});

        dieListe.anhaengen(926);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926});

        assertFalse("Fehler: Element 520 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(520));
        dieListe.anhaengen(344);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344});

        dieListe.anhaengen(167);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167});

        dieListe.anhaengen(269);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269});

        dieListe.anhaengen(625);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625});

        assertTrue("Fehler: Element 753 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(753));
        assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985));
        assertFalse("Fehler: Element 21 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(21));
        assertTrue("Fehler: Element 927 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(927));
        assertTrue("Fehler: Element 564 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(564));
        assertFalse("Fehler: Element 766 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(766));
        dieListe.anhaengen(672);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672});

        assertFalse("Fehler: Element 365 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(365));
        assertTrue("Fehler: Element 926 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(926));
        assertTrue("Fehler: Element 625 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(625));
        assertFalse("Fehler: Element 685 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(685));
        dieListe.anhaengen(389);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389});

        assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389));
        assertFalse("Fehler: Element 955 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(955));
        dieListe.anhaengen(988);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988});

        dieListe.anhaengen(101);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101});

        assertTrue("Fehler: Element 269 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(269));
        dieListe.anhaengen(994);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994});

        assertTrue("Fehler: Element 624 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(624));
        dieListe.anhaengen(709);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709});

        assertFalse("Fehler: Element 336 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(336));
        dieListe.anhaengen(547);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547});

        assertFalse("Fehler: Element 881 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(881));
        dieListe.anhaengen(709);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709});

        assertFalse("Fehler: Element 339 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(339));
        dieListe.anhaengen(454);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454});

        assertTrue("Fehler: Element 101 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(101));
        dieListe.anhaengen(149);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149});

        assertFalse("Fehler: Element 141 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(141));
        assertFalse("Fehler: Element 450 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(450));
        dieListe.anhaengen(253);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253});

        assertFalse("Fehler: Element 281 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(281));
        assertTrue("Fehler: Element 547 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(547));
        assertTrue("Fehler: Element 454 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(454));
        dieListe.anhaengen(772);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772});

        assertFalse("Fehler: Element 596 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(596));
        assertTrue("Fehler: Element 564 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(564));
        dieListe.anhaengen(310);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310});

        dieListe.anhaengen(781);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781});

        assertFalse("Fehler: Element 774 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(774));
        dieListe.anhaengen(57);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57});

        dieListe.anhaengen(28);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28});

        dieListe.anhaengen(861);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861});

        dieListe.anhaengen(668);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668});

        assertTrue("Fehler: Element 772 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(772));
        assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861));
        assertTrue("Fehler: Element 994 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(994));
        dieListe.anhaengen(813);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813});

        assertFalse("Fehler: Element 128 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(128));
        assertFalse("Fehler: Element 524 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(524));
        assertTrue("Fehler: Element 772 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(772));
        assertFalse("Fehler: Element 289 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(289));
        dieListe.anhaengen(887);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887});

        assertTrue("Fehler: Element 772 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(772));
        assertFalse("Fehler: Element 626 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(626));
        dieListe.anhaengen(944);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944});

        dieListe.anhaengen(828);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828});

        assertFalse("Fehler: Element 314 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(314));
        assertFalse("Fehler: Element 46 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(46));
        dieListe.anhaengen(762);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762});

        assertFalse("Fehler: Element 346 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(346));
        assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485));
        assertTrue("Fehler: Element 762 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(762));
        dieListe.anhaengen(9);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9});

        dieListe.anhaengen(360);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360});

        assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709));
        dieListe.anhaengen(564);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564});

        dieListe.anhaengen(20);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564, 20});

        dieListe.anhaengen(564);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564, 20, 564});

        assertTrue("Fehler: Element 927 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(927));
        dieListe.anhaengen(85);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564, 20, 564, 85});

        dieListe.anhaengen(987);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564, 20, 564, 85, 987});

        assertFalse("Fehler: Element 900 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(900));
        assertFalse("Fehler: Element 98 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(98));
        assertFalse("Fehler: Element 888 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(888));
        dieListe.anhaengen(963);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564, 20, 564, 85, 987, 963});

        assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709));
        assertFalse("Fehler: Element 874 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(874));
        assertFalse("Fehler: Element 937 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(937));
        assertFalse("Fehler: Element 607 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(607));
        assertTrue("Fehler: Element 887 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(887));
        assertFalse("Fehler: Element 972 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(972));
        dieListe.anhaengen(693);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564, 20, 564, 85, 987, 963, 693});

        assertFalse("Fehler: Element 975 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(975));
        dieListe.anhaengen(897);
        Tester.pruefeListenInhalt(dieListe, new int[]{624, 753, 927, 342, 564, 926, 344, 167, 269, 625, 672, 389, 988, 101, 994, 709, 547, 709, 454, 149, 253, 772, 310, 781, 57, 28, 861, 668, 813, 887, 944, 828, 762, 9, 360, 564, 20, 564, 85, 987, 963, 693, 897});

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

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

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

        assertFalse("Fehler: Element 823 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(823));
        assertFalse("Fehler: Element 62 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(62));
        dieListe.anhaengen(529);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529});

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

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

        assertTrue("Fehler: Element 116 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(116));
        dieListe.anhaengen(319);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319});

        assertFalse("Fehler: Element 139 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(139));
        dieListe.anhaengen(658);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658});

        assertTrue("Fehler: Element 649 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(649));
        assertTrue("Fehler: Element 636 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(636));
        assertFalse("Fehler: Element 450 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(450));
        dieListe.anhaengen(869);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869});

        assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978));
        dieListe.anhaengen(664);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664});

        dieListe.anhaengen(659);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659});

        dieListe.anhaengen(900);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900});

        dieListe.anhaengen(607);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607});

        dieListe.anhaengen(276);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276});

        dieListe.anhaengen(321);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321});

        assertFalse("Fehler: Element 745 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(745));
        assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415));
        dieListe.anhaengen(92);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92});

        assertTrue("Fehler: Element 659 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(659));
        assertFalse("Fehler: Element 929 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(929));
        assertTrue("Fehler: Element 658 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(658));
        assertTrue("Fehler: Element 649 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(649));
        dieListe.anhaengen(923);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923});

        dieListe.anhaengen(965);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965});

        assertFalse("Fehler: Element 292 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(292));
        dieListe.anhaengen(799);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799});

        dieListe.anhaengen(619);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619});

        assertFalse("Fehler: Element 85 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(85));
        dieListe.anhaengen(798);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798});

        dieListe.anhaengen(397);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397});

        assertTrue("Fehler: Element 869 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(869));
        assertFalse("Fehler: Element 766 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(766));
        dieListe.anhaengen(247);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247});

        dieListe.anhaengen(67);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67});

        dieListe.anhaengen(272);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272});

        dieListe.anhaengen(477);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477});

        assertFalse("Fehler: Element 299 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(299));
        assertFalse("Fehler: Element 267 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(267));
        assertTrue("Fehler: Element 965 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(965));
        dieListe.anhaengen(159);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159});

        assertTrue("Fehler: Element 116 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(116));
        assertTrue("Fehler: Element 664 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(664));
        dieListe.anhaengen(421);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421});

        assertTrue("Fehler: Element 92 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(92));
        assertFalse("Fehler: Element 931 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(931));
        assertTrue("Fehler: Element 869 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(869));
        dieListe.anhaengen(940);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940});

        dieListe.anhaengen(865);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865});

        dieListe.anhaengen(248);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248});

        dieListe.anhaengen(698);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698});

        dieListe.anhaengen(199);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199});

        dieListe.anhaengen(735);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735});

        assertFalse("Fehler: Element 78 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(78));
        dieListe.anhaengen(814);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814});

        assertFalse("Fehler: Element 9 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(9));
        dieListe.anhaengen(744);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744});

        assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985));
        assertFalse("Fehler: Element 465 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(465));
        assertTrue("Fehler: Element 698 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(698));
        assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781));
        assertFalse("Fehler: Element 165 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(165));
        assertFalse("Fehler: Element 26 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(26));
        assertFalse("Fehler: Element 308 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(308));
        assertTrue("Fehler: Element 636 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(636));
        dieListe.anhaengen(503);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503});

        assertTrue("Fehler: Element 659 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(659));
        dieListe.anhaengen(629);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629});

        dieListe.anhaengen(848);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848});

        dieListe.anhaengen(765);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765});

        dieListe.anhaengen(738);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738});

        assertFalse("Fehler: Element 500 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(500));
        assertTrue("Fehler: Element 900 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(900));
        assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156));
        dieListe.anhaengen(366);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366});

        dieListe.anhaengen(915);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915});

        assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421));
        assertTrue("Fehler: Element 659 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(659));
        assertFalse("Fehler: Element 717 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(717));
        assertTrue("Fehler: Element 247 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(247));
        dieListe.anhaengen(479);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479});

        assertTrue("Fehler: Element 798 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(798));
        dieListe.anhaengen(198);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479, 198});

        dieListe.anhaengen(189);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479, 198, 189});

        dieListe.anhaengen(594);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479, 198, 189, 594});

        assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230));
        assertFalse("Fehler: Element 901 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(901));
        dieListe.anhaengen(118);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479, 198, 189, 594, 118});

        dieListe.anhaengen(480);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479, 198, 189, 594, 118, 480});

        assertFalse("Fehler: Element 4 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(4));
        assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313));
        dieListe.anhaengen(383);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479, 198, 189, 594, 118, 480, 383});

        assertTrue("Fehler: Element 765 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(765));
        dieListe.anhaengen(720);
        Tester.pruefeListenInhalt(dieListe, new int[]{116, 649, 529, 636, 198, 319, 658, 869, 664, 659, 900, 607, 276, 321, 92, 923, 965, 799, 619, 798, 397, 247, 67, 272, 477, 159, 421, 940, 865, 248, 698, 199, 735, 814, 744, 503, 629, 848, 765, 738, 366, 915, 479, 198, 189, 594, 118, 480, 383, 720});

    }

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

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

        assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302));
        assertFalse("Fehler: Element 114 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(114));
        dieListe.anhaengen(33);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33});

        dieListe.anhaengen(231);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231});

        dieListe.anhaengen(429);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429});

        assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231));
        assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231));
        assertFalse("Fehler: Element 502 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(502));
        assertTrue("Fehler: Element 429 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(429));
        dieListe.anhaengen(336);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336});

        assertTrue("Fehler: Element 336 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(336));
        assertFalse("Fehler: Element 792 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(792));
        assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231));
        dieListe.anhaengen(838);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838});

        dieListe.anhaengen(81);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81});

        dieListe.anhaengen(180);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180});

        dieListe.anhaengen(922);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922});

        assertTrue("Fehler: Element 336 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(336));
        assertFalse("Fehler: Element 232 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(232));
        assertTrue("Fehler: Element 81 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(81));
        assertTrue("Fehler: Element 81 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(81));
        assertFalse("Fehler: Element 522 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(522));
        assertFalse("Fehler: Element 1 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(1));
        dieListe.anhaengen(15);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15});

        assertFalse("Fehler: Element 85 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(85));
        assertTrue("Fehler: Element 922 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(922));
        assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231));
        assertTrue("Fehler: Element 838 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(838));
        dieListe.anhaengen(120);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120});

        dieListe.anhaengen(58);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58});

        dieListe.anhaengen(901);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901});

        assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15));
        dieListe.anhaengen(285);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285});

        dieListe.anhaengen(897);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897});

        dieListe.anhaengen(51);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51});

        dieListe.anhaengen(155);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155});

        assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451));
        assertFalse("Fehler: Element 348 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(348));
        assertFalse("Fehler: Element 88 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(88));
        assertFalse("Fehler: Element 776 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(776));
        assertFalse("Fehler: Element 484 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(484));
        assertFalse("Fehler: Element 673 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(673));
        dieListe.anhaengen(363);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363});

        dieListe.anhaengen(400);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400});

        dieListe.anhaengen(618);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618});

        assertFalse("Fehler: Element 679 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(679));
        assertFalse("Fehler: Element 200 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(200));
        dieListe.anhaengen(776);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776});

        dieListe.anhaengen(239);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239});

        assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302));
        assertFalse("Fehler: Element 472 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(472));
        assertTrue("Fehler: Element 155 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(155));
        assertFalse("Fehler: Element 226 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(226));
        assertFalse("Fehler: Element 174 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(174));
        assertFalse("Fehler: Element 316 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(316));
        dieListe.anhaengen(395);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395});

        assertTrue("Fehler: Element 58 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(58));
        dieListe.anhaengen(871);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871});

        dieListe.anhaengen(65);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65});

        dieListe.anhaengen(26);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26});

        dieListe.anhaengen(761);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761});

        assertTrue("Fehler: Element 120 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(120));
        dieListe.anhaengen(411);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411});

        dieListe.anhaengen(846);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846});

        dieListe.anhaengen(512);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512});

        assertFalse("Fehler: Element 378 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(378));
        assertTrue("Fehler: Element 81 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(81));
        assertFalse("Fehler: Element 737 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(737));
        assertFalse("Fehler: Element 1 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(1));
        dieListe.anhaengen(258);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258});

        dieListe.anhaengen(392);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392});

        assertFalse("Fehler: Element 252 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(252));
        dieListe.anhaengen(153);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153});

        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        assertFalse("Fehler: Element 272 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(272));
        dieListe.anhaengen(377);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377});

        dieListe.anhaengen(138);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138});

        assertTrue("Fehler: Element 411 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(411));
        assertTrue("Fehler: Element 180 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(180));
        dieListe.anhaengen(925);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925});

        assertFalse("Fehler: Element 647 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(647));
        dieListe.anhaengen(59);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59});

        dieListe.anhaengen(986);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986});

        dieListe.anhaengen(197);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197});

        assertFalse("Fehler: Element 709 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(709));
        dieListe.anhaengen(980);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197, 980});

        dieListe.anhaengen(812);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197, 980, 812});

        dieListe.anhaengen(747);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197, 980, 812, 747});

        assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358));
        dieListe.anhaengen(107);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197, 980, 812, 747, 107});

        dieListe.anhaengen(336);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197, 980, 812, 747, 107, 336});

        assertFalse("Fehler: Element 70 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(70));
        assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701));
        assertFalse("Fehler: Element 666 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(666));
        dieListe.anhaengen(793);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197, 980, 812, 747, 107, 336, 793});

        dieListe.anhaengen(635);
        Tester.pruefeListenInhalt(dieListe, new int[]{302, 444, 33, 231, 429, 336, 838, 81, 180, 922, 15, 120, 58, 901, 285, 897, 51, 155, 363, 400, 618, 776, 239, 395, 871, 65, 26, 761, 411, 846, 512, 258, 392, 153, 377, 138, 925, 59, 986, 197, 980, 812, 747, 107, 336, 793, 635});

    }

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

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

        dieListe.anhaengen(737);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737});

        assertTrue("Fehler: Element 764 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(764));
        assertTrue("Fehler: Element 764 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(764));
        assertFalse("Fehler: Element 882 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(882));
        dieListe.anhaengen(778);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778});

        dieListe.anhaengen(200);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200});

        dieListe.anhaengen(222);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222});

        dieListe.anhaengen(316);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316});

        dieListe.anhaengen(977);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977});

        assertFalse("Fehler: Element 999 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(999));
        dieListe.anhaengen(466);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466});

        assertFalse("Fehler: Element 99 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(99));
        dieListe.anhaengen(546);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546});

        assertFalse("Fehler: Element 618 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(618));
        assertTrue("Fehler: Element 222 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(222));
        dieListe.anhaengen(839);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839});

        dieListe.anhaengen(683);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683});

        dieListe.anhaengen(780);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780});

        assertTrue("Fehler: Element 222 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(222));
        assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20));
        dieListe.anhaengen(619);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619});

        assertFalse("Fehler: Element 256 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(256));
        assertFalse("Fehler: Element 434 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(434));
        dieListe.anhaengen(634);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634});

        assertTrue("Fehler: Element 200 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(200));
        assertTrue("Fehler: Element 327 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(327));
        assertTrue("Fehler: Element 316 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(316));
        assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367));
        assertFalse("Fehler: Element 625 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(625));
        dieListe.anhaengen(344);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344});

        dieListe.anhaengen(835);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835});

        dieListe.anhaengen(968);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968});

        assertFalse("Fehler: Element 497 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(497));
        assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965));
        dieListe.anhaengen(387);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387});

        dieListe.anhaengen(390);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390});

        dieListe.anhaengen(889);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889});

        assertTrue("Fehler: Element 390 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(390));
        dieListe.anhaengen(233);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233});

        assertTrue("Fehler: Element 390 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(390));
        assertFalse("Fehler: Element 657 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(657));
        dieListe.anhaengen(82);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82});

        dieListe.anhaengen(703);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703});

        assertFalse("Fehler: Element 170 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(170));
        assertTrue("Fehler: Element 835 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(835));
        assertTrue("Fehler: Element 390 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(390));
        assertFalse("Fehler: Element 969 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(969));
        assertTrue("Fehler: Element 390 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(390));
        assertTrue("Fehler: Element 737 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(737));
        assertFalse("Fehler: Element 207 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(207));
        assertFalse("Fehler: Element 289 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(289));
        dieListe.anhaengen(651);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651});

        assertTrue("Fehler: Element 889 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(889));
        dieListe.anhaengen(960);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960});

        assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778));
        dieListe.anhaengen(33);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33});

        assertTrue("Fehler: Element 466 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(466));
        dieListe.anhaengen(100);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100});

        dieListe.anhaengen(652);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652});

        dieListe.anhaengen(908);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908});

        assertTrue("Fehler: Element 390 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(390));
        dieListe.anhaengen(311);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311});

        assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622));
        dieListe.anhaengen(593);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593});

        dieListe.anhaengen(803);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803});

        dieListe.anhaengen(545);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545});

        assertTrue("Fehler: Element 33 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(33));
        assertTrue("Fehler: Element 390 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(390));
        assertTrue("Fehler: Element 311 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(311));
        assertFalse("Fehler: Element 361 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(361));
        dieListe.anhaengen(616);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616});

        dieListe.anhaengen(265);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265});

        dieListe.anhaengen(819);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819});

        dieListe.anhaengen(323);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323});

        assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306));
        dieListe.anhaengen(598);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598});

        assertTrue("Fehler: Element 327 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(327));
        assertFalse("Fehler: Element 377 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(377));
        assertTrue("Fehler: Element 593 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(593));
        dieListe.anhaengen(174);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174});

        dieListe.anhaengen(619);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619});

        dieListe.anhaengen(678);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619, 678});

        dieListe.anhaengen(656);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619, 678, 656});

        dieListe.anhaengen(892);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619, 678, 656, 892});

        assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892));
        assertFalse("Fehler: Element 995 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(995));
        assertFalse("Fehler: Element 54 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(54));
        assertTrue("Fehler: Element 683 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(683));
        assertFalse("Fehler: Element 85 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(85));
        dieListe.anhaengen(160);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619, 678, 656, 892, 160});

        assertFalse("Fehler: Element 872 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(872));
        dieListe.anhaengen(433);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619, 678, 656, 892, 160, 433});

        assertFalse("Fehler: Element 133 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(133));
        dieListe.anhaengen(17);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619, 678, 656, 892, 160, 433, 17});

        assertTrue("Fehler: Element 233 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(233));
        assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892));
        dieListe.anhaengen(211);
        Tester.pruefeListenInhalt(dieListe, new int[]{764, 327, 737, 778, 200, 222, 316, 977, 466, 546, 839, 683, 780, 619, 634, 344, 835, 968, 387, 390, 889, 233, 82, 703, 651, 960, 33, 100, 652, 908, 311, 593, 803, 545, 616, 265, 819, 323, 598, 174, 619, 678, 656, 892, 160, 433, 17, 211});

    }

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

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

        assertFalse("Fehler: Element 854 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(854));
        assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619));
        assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72));
        assertFalse("Fehler: Element 263 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(263));
        assertFalse("Fehler: Element 601 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(601));
        assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725));
        dieListe.anhaengen(65);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65});

        assertFalse("Fehler: Element 164 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(164));
        assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725));
        dieListe.anhaengen(81);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81});

        assertFalse("Fehler: Element 182 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(182));
        assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725));
        dieListe.anhaengen(898);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898});

        assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239));
        assertFalse("Fehler: Element 2 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(2));
        assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335));
        dieListe.anhaengen(187);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187});

        dieListe.anhaengen(711);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711});

        dieListe.anhaengen(6);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6});

        assertFalse("Fehler: Element 873 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(873));
        dieListe.anhaengen(421);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421});

        assertTrue("Fehler: Element 711 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(711));
        assertFalse("Fehler: Element 103 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(103));
        dieListe.anhaengen(430);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430});

        assertFalse("Fehler: Element 250 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(250));
        assertFalse("Fehler: Element 517 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(517));
        dieListe.anhaengen(951);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951});

        assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421));
        dieListe.anhaengen(114);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114});

        assertFalse("Fehler: Element 518 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(518));
        assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725));
        assertFalse("Fehler: Element 417 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(417));
        dieListe.anhaengen(863);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863});

        dieListe.anhaengen(951);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951});

        dieListe.anhaengen(890);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890});

        dieListe.anhaengen(816);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816});

        assertFalse("Fehler: Element 866 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(866));
        dieListe.anhaengen(146);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146});

        dieListe.anhaengen(304);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304});

        dieListe.anhaengen(48);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48});

        dieListe.anhaengen(96);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96});

        dieListe.anhaengen(187);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187});

        dieListe.anhaengen(267);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267});

        assertFalse("Fehler: Element 302 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(302));
        dieListe.anhaengen(562);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562});

        assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421));
        dieListe.anhaengen(442);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442});

        assertTrue("Fehler: Element 81 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(81));
        assertFalse("Fehler: Element 291 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(291));
        dieListe.anhaengen(944);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944});

        dieListe.anhaengen(191);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191});

        assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890));
        assertFalse("Fehler: Element 7 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(7));
        assertFalse("Fehler: Element 215 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(215));
        assertFalse("Fehler: Element 247 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(247));
        assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602));
        assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146));
        assertTrue("Fehler: Element 898 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(898));
        dieListe.anhaengen(369);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369});

        dieListe.anhaengen(699);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699});

        dieListe.anhaengen(864);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864});

        dieListe.anhaengen(886);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886});

        assertFalse("Fehler: Element 92 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(92));
        dieListe.anhaengen(400);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400});

        assertFalse("Fehler: Element 379 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(379));
        assertFalse("Fehler: Element 566 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(566));
        assertTrue("Fehler: Element 369 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(369));
        assertTrue("Fehler: Element 699 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(699));
        dieListe.anhaengen(274);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274});

        assertTrue("Fehler: Element 48 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(48));
        assertFalse("Fehler: Element 396 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(396));
        dieListe.anhaengen(50);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50});

        dieListe.anhaengen(343);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343});

        assertTrue("Fehler: Element 944 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(944));
        assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114));
        dieListe.anhaengen(964);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964});

        assertFalse("Fehler: Element 27 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(27));
        assertFalse("Fehler: Element 770 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(770));
        assertFalse("Fehler: Element 152 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(152));
        dieListe.anhaengen(421);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964, 421});

        assertFalse("Fehler: Element 670 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(670));
        dieListe.anhaengen(805);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964, 421, 805});

        assertFalse("Fehler: Element 9 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(9));
        assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72));
        assertTrue("Fehler: Element 191 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(191));
        dieListe.anhaengen(487);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964, 421, 805, 487});

        assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421));
        assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96));
        dieListe.anhaengen(76);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964, 421, 805, 487, 76});

        assertFalse("Fehler: Element 298 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(298));
        dieListe.anhaengen(847);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964, 421, 805, 487, 76, 847});

        assertTrue("Fehler: Element 863 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(863));
        dieListe.anhaengen(908);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964, 421, 805, 487, 76, 847, 908});

        dieListe.anhaengen(374);
        Tester.pruefeListenInhalt(dieListe, new int[]{725, 72, 65, 81, 898, 187, 711, 6, 421, 430, 951, 114, 863, 951, 890, 816, 146, 304, 48, 96, 187, 267, 562, 442, 944, 191, 369, 699, 864, 886, 400, 274, 50, 343, 964, 421, 805, 487, 76, 847, 908, 374});

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

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

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

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

        assertFalse("Fehler: Element 755 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(755));
        assertTrue("Fehler: Element 708 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(708));
        dieListe.anhaengen(64);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64});

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

        dieListe.anhaengen(909);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909});

        assertTrue("Fehler: Element 708 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(708));
        dieListe.anhaengen(388);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388});

        dieListe.anhaengen(550);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550});

        dieListe.anhaengen(761);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761});

        dieListe.anhaengen(214);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214});

        assertTrue("Fehler: Element 550 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(550));
        dieListe.anhaengen(506);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506});

        dieListe.anhaengen(672);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672});

        assertFalse("Fehler: Element 25 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(25));
        assertFalse("Fehler: Element 893 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(893));
        assertFalse("Fehler: Element 406 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(406));
        dieListe.anhaengen(553);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553});

        dieListe.anhaengen(472);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472});

        assertTrue("Fehler: Element 214 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(214));
        dieListe.anhaengen(447);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447});

        assertTrue("Fehler: Element 454 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(454));
        assertTrue("Fehler: Element 506 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(506));
        dieListe.anhaengen(790);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790});

        dieListe.anhaengen(732);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732});

        assertTrue("Fehler: Element 447 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(447));
        assertTrue("Fehler: Element 214 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(214));
        dieListe.anhaengen(250);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250});

        assertFalse("Fehler: Element 904 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(904));
        assertFalse("Fehler: Element 402 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(402));
        assertFalse("Fehler: Element 94 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(94));
        dieListe.anhaengen(89);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89});

        assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672));
        assertTrue("Fehler: Element 250 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(250));
        dieListe.anhaengen(308);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308});

        dieListe.anhaengen(154);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154});

        assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76));
        dieListe.anhaengen(187);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187});

        assertFalse("Fehler: Element 762 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(762));
        dieListe.anhaengen(159);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159});

        dieListe.anhaengen(993);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993});

        assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269));
        dieListe.anhaengen(341);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341});

        assertFalse("Fehler: Element 717 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(717));
        assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388));
        assertFalse("Fehler: Element 74 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(74));
        dieListe.anhaengen(300);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300});

        dieListe.anhaengen(203);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203});

        dieListe.anhaengen(932);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932});

        assertTrue("Fehler: Element 187 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(187));
        assertFalse("Fehler: Element 348 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(348));
        dieListe.anhaengen(940);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940});

        assertFalse("Fehler: Element 201 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(201));
        assertTrue("Fehler: Element 472 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(472));
        dieListe.anhaengen(836);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836});

        assertFalse("Fehler: Element 889 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(889));
        assertFalse("Fehler: Element 798 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(798));
        dieListe.anhaengen(131);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131});

        assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64));
        dieListe.anhaengen(837);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837});

        assertFalse("Fehler: Element 745 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(745));
        dieListe.anhaengen(945);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945});

        assertTrue("Fehler: Element 187 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(187));
        assertTrue("Fehler: Element 837 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(837));
        assertFalse("Fehler: Element 162 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(162));
        assertFalse("Fehler: Element 969 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(969));
        dieListe.anhaengen(347);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347});

        assertFalse("Fehler: Element 833 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(833));
        dieListe.anhaengen(396);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396});

        assertTrue("Fehler: Element 341 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(341));
        dieListe.anhaengen(797);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797});

        dieListe.anhaengen(79);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79});

        assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672));
        dieListe.anhaengen(697);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697});

        dieListe.anhaengen(474);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697, 474});

        assertFalse("Fehler: Element 498 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(498));
        dieListe.anhaengen(302);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697, 474, 302});

        assertTrue("Fehler: Element 454 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(454));
        dieListe.anhaengen(121);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697, 474, 302, 121});

        assertFalse("Fehler: Element 618 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(618));
        assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265));
        assertFalse("Fehler: Element 530 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(530));
        assertFalse("Fehler: Element 517 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(517));
        assertTrue("Fehler: Element 214 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(214));
        assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672));
        dieListe.anhaengen(707);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697, 474, 302, 121, 707});

        dieListe.anhaengen(861);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697, 474, 302, 121, 707, 861});

        assertTrue("Fehler: Element 836 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(836));
        assertFalse("Fehler: Element 955 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(955));
        assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672));
        assertFalse("Fehler: Element 270 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(270));
        assertTrue("Fehler: Element 89 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(89));
        dieListe.anhaengen(256);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697, 474, 302, 121, 707, 861, 256});

        assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501));
        dieListe.anhaengen(161);
        Tester.pruefeListenInhalt(dieListe, new int[]{613, 454, 708, 64, 581, 909, 388, 550, 761, 214, 506, 672, 553, 472, 447, 790, 732, 250, 89, 308, 154, 187, 159, 993, 341, 300, 203, 932, 940, 836, 131, 837, 945, 347, 396, 797, 79, 697, 474, 302, 121, 707, 861, 256, 161});

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

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

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

        dieListe.anhaengen(964);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964});

        dieListe.anhaengen(951);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951});

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

        assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964));
        dieListe.anhaengen(976);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976});

        assertTrue("Fehler: Element 976 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(976));
        dieListe.anhaengen(54);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54});

        assertFalse("Fehler: Element 667 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(667));
        dieListe.anhaengen(530);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530});

        dieListe.anhaengen(91);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91});

        assertTrue("Fehler: Element 530 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(530));
        dieListe.anhaengen(714);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714});

        dieListe.anhaengen(979);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979});

        assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964));
        dieListe.anhaengen(918);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918});

        dieListe.anhaengen(511);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511});

        assertTrue("Fehler: Element 511 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(511));
        dieListe.anhaengen(785);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785});

        dieListe.anhaengen(749);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749});

        assertFalse("Fehler: Element 264 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(264));
        dieListe.anhaengen(139);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139});

        assertTrue("Fehler: Element 951 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(951));
        assertTrue("Fehler: Element 785 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(785));
        assertFalse("Fehler: Element 260 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(260));
        assertFalse("Fehler: Element 483 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(483));
        dieListe.anhaengen(554);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554});

        assertFalse("Fehler: Element 789 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(789));
        assertTrue("Fehler: Element 54 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(54));
        dieListe.anhaengen(64);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64});

        assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978));
        assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151));
        assertTrue("Fehler: Element 313 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(313));
        assertTrue("Fehler: Element 139 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(139));
        dieListe.anhaengen(135);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135});

        assertTrue("Fehler: Element 54 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(54));
        dieListe.anhaengen(339);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339});

        dieListe.anhaengen(591);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591});

        assertTrue("Fehler: Element 339 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(339));
        assertTrue("Fehler: Element 979 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(979));
        dieListe.anhaengen(995);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995});

        assertTrue("Fehler: Element 511 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(511));
        dieListe.anhaengen(160);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160});

        dieListe.anhaengen(80);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80});

        dieListe.anhaengen(767);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767});

        dieListe.anhaengen(105);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105});

        dieListe.anhaengen(189);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189});

        assertTrue("Fehler: Element 530 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(530));
        dieListe.anhaengen(200);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200});

        assertTrue("Fehler: Element 80 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(80));
        assertFalse("Fehler: Element 500 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(500));
        assertTrue("Fehler: Element 105 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(105));
        assertFalse("Fehler: Element 37 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(37));
        assertFalse("Fehler: Element 635 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(635));
        assertTrue("Fehler: Element 995 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(995));
        assertFalse("Fehler: Element 537 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(537));
        dieListe.anhaengen(697);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697});

        dieListe.anhaengen(592);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592});

        dieListe.anhaengen(399);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399});

        assertFalse("Fehler: Element 938 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(938));
        dieListe.anhaengen(168);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168});

        assertTrue("Fehler: Element 592 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(592));
        assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64));
        assertFalse("Fehler: Element 32 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(32));
        dieListe.anhaengen(656);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656});

        assertTrue("Fehler: Element 979 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(979));
        dieListe.anhaengen(863);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863});

        assertFalse("Fehler: Element 457 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(457));
        dieListe.anhaengen(37);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37});

        assertTrue("Fehler: Element 200 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(200));
        assertFalse("Fehler: Element 136 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(136));
        assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964));
        dieListe.anhaengen(842);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842});

        dieListe.anhaengen(667);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667});

        dieListe.anhaengen(909);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909});

        dieListe.anhaengen(927);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927});

        dieListe.anhaengen(513);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513});

        assertFalse("Fehler: Element 84 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(84));
        dieListe.anhaengen(584);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584});

        dieListe.anhaengen(970);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970});

        dieListe.anhaengen(754);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970, 754});

        dieListe.anhaengen(695);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970, 754, 695});

        dieListe.anhaengen(248);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970, 754, 695, 248});

        assertTrue("Fehler: Element 918 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(918));
        assertFalse("Fehler: Element 34 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(34));
        assertTrue("Fehler: Element 667 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(667));
        dieListe.anhaengen(378);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970, 754, 695, 248, 378});

        dieListe.anhaengen(138);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970, 754, 695, 248, 378, 138});

        assertFalse("Fehler: Element 231 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(231));
        dieListe.anhaengen(71);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970, 754, 695, 248, 378, 138, 71});

        assertFalse("Fehler: Element 1 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(1));
        assertFalse("Fehler: Element 721 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(721));
        assertFalse("Fehler: Element 895 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(895));
        dieListe.anhaengen(597);
        Tester.pruefeListenInhalt(dieListe, new int[]{151, 313, 964, 951, 375, 976, 54, 530, 91, 714, 979, 918, 511, 785, 749, 139, 554, 64, 135, 339, 591, 995, 160, 80, 767, 105, 189, 200, 697, 592, 399, 168, 656, 863, 37, 842, 667, 909, 927, 513, 584, 970, 754, 695, 248, 378, 138, 71, 597});

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

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

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

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

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

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

        dieListe.anhaengen(394);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394});

        assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950));
        assertFalse("Fehler: Element 895 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(895));
        assertFalse("Fehler: Element 757 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(757));
        assertFalse("Fehler: Element 321 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(321));
        dieListe.anhaengen(187);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187});

        dieListe.anhaengen(763);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763});

        assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100));
        dieListe.anhaengen(3);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3});

        dieListe.anhaengen(623);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623});

        dieListe.anhaengen(53);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53});

        dieListe.anhaengen(468);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468});

        dieListe.anhaengen(194);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194});

        dieListe.anhaengen(373);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373});

        assertFalse("Fehler: Element 809 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(809));
        assertFalse("Fehler: Element 29 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(29));
        assertFalse("Fehler: Element 456 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(456));
        dieListe.anhaengen(633);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633});

        assertTrue("Fehler: Element 681 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(681));
        dieListe.anhaengen(875);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875});

        dieListe.anhaengen(294);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294});

        dieListe.anhaengen(995);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995});

        assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100));
        dieListe.anhaengen(308);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308});

        dieListe.anhaengen(354);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354});

        assertFalse("Fehler: Element 900 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(900));
        dieListe.anhaengen(783);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783});

        assertTrue("Fehler: Element 633 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(633));
        dieListe.anhaengen(387);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387});

        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        assertTrue("Fehler: Element 294 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(294));
        dieListe.anhaengen(947);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947});

        assertTrue("Fehler: Element 53 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(53));
        dieListe.anhaengen(832);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832});

        dieListe.anhaengen(689);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689});

        assertTrue("Fehler: Element 468 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(468));
        assertTrue("Fehler: Element 187 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(187));
        dieListe.anhaengen(872);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872});

        assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622));
        dieListe.anhaengen(643);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643});

        assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239));
        dieListe.anhaengen(115);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115});

        assertTrue("Fehler: Element 308 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(308));
        dieListe.anhaengen(493);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493});

        dieListe.anhaengen(118);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118});

        assertTrue("Fehler: Element 689 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(689));
        assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571));
        dieListe.anhaengen(207);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207});

        dieListe.anhaengen(610);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610});

        assertFalse("Fehler: Element 599 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(599));
        dieListe.anhaengen(694);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694});

        assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194));
        assertTrue("Fehler: Element 872 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(872));
        dieListe.anhaengen(197);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197});

        assertFalse("Fehler: Element 402 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(402));
        dieListe.anhaengen(384);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384});

        dieListe.anhaengen(471);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471});

        assertFalse("Fehler: Element 498 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(498));
        dieListe.anhaengen(434);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434});

        dieListe.anhaengen(353);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353});

        dieListe.anhaengen(69);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69});

        dieListe.anhaengen(263);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263});

        dieListe.anhaengen(946);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946});

        dieListe.anhaengen(933);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933});

        assertFalse("Fehler: Element 674 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(674));
        dieListe.anhaengen(650);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650});

        dieListe.anhaengen(183);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183});

        dieListe.anhaengen(369);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369});

        dieListe.anhaengen(755);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755});

        assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118));
        dieListe.anhaengen(21);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21});

        dieListe.anhaengen(122);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122});

        assertFalse("Fehler: Element 417 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(417));
        assertFalse("Fehler: Element 774 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(774));
        dieListe.anhaengen(931);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931});

        assertTrue("Fehler: Element 294 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(294));
        dieListe.anhaengen(27);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27});

        assertFalse("Fehler: Element 342 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(342));
        assertTrue("Fehler: Element 493 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(493));
        dieListe.anhaengen(772);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772});

        dieListe.anhaengen(698);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698});

        dieListe.anhaengen(912);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698, 912});

        assertFalse("Fehler: Element 464 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(464));
        assertTrue("Fehler: Element 832 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(832));
        dieListe.anhaengen(97);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698, 912, 97});

        assertFalse("Fehler: Element 279 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(279));
        dieListe.anhaengen(328);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698, 912, 97, 328});

        dieListe.anhaengen(463);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698, 912, 97, 328, 463});

        assertFalse("Fehler: Element 615 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(615));
        assertFalse("Fehler: Element 483 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(483));
        assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623));
        dieListe.anhaengen(400);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698, 912, 97, 328, 463, 400});

        dieListe.anhaengen(437);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698, 912, 97, 328, 463, 400, 437});

        dieListe.anhaengen(435);
        Tester.pruefeListenInhalt(dieListe, new int[]{239, 763, 681, 49, 100, 394, 187, 763, 3, 623, 53, 468, 194, 373, 633, 875, 294, 995, 308, 354, 783, 387, 947, 832, 689, 872, 643, 115, 493, 118, 207, 610, 694, 197, 384, 471, 434, 353, 69, 263, 946, 933, 650, 183, 369, 755, 21, 122, 931, 27, 772, 698, 912, 97, 328, 463, 400, 437, 435});

    }

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

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

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

        dieListe.anhaengen(588);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588});

        assertFalse("Fehler: Element 462 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(462));
        assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503));
        assertTrue("Fehler: Element 940 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(940));
        assertTrue("Fehler: Element 622 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(622));
        assertFalse("Fehler: Element 490 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(490));
        assertFalse("Fehler: Element 730 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(730));
        assertFalse("Fehler: Element 445 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(445));
        dieListe.anhaengen(575);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575});

        dieListe.anhaengen(468);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468});

        dieListe.anhaengen(283);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283});

        dieListe.anhaengen(162);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162});

        dieListe.anhaengen(103);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103});

        assertFalse("Fehler: Element 855 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(855));
        dieListe.anhaengen(341);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341});

        assertFalse("Fehler: Element 184 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(184));
        dieListe.anhaengen(590);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590});

        dieListe.anhaengen(940);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940});

        assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51));
        dieListe.anhaengen(389);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389});

        assertTrue("Fehler: Element 622 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(622));
        assertFalse("Fehler: Element 253 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(253));
        assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389));
        dieListe.anhaengen(282);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282});

        dieListe.anhaengen(666);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666});

        assertFalse("Fehler: Element 443 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(443));
        dieListe.anhaengen(380);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380});

        dieListe.anhaengen(659);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659});

        dieListe.anhaengen(554);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554});

        dieListe.anhaengen(820);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820});

        dieListe.anhaengen(508);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508});

        dieListe.anhaengen(435);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435});

        dieListe.anhaengen(547);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547});

        assertFalse("Fehler: Element 914 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(914));
        assertTrue("Fehler: Element 554 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(554));
        assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503));
        dieListe.anhaengen(825);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825});

        dieListe.anhaengen(875);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875});

        dieListe.anhaengen(683);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683});

        assertFalse("Fehler: Element 318 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(318));
        assertFalse("Fehler: Element 604 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(604));
        dieListe.anhaengen(479);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479});

        dieListe.anhaengen(828);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828});

        dieListe.anhaengen(111);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111});

        assertFalse("Fehler: Element 293 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(293));
        assertFalse("Fehler: Element 699 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(699));
        assertFalse("Fehler: Element 697 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(697));
        dieListe.anhaengen(686);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686});

        assertTrue("Fehler: Element 575 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(575));
        dieListe.anhaengen(731);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731});

        dieListe.anhaengen(183);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183});

        assertFalse("Fehler: Element 196 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(196));
        dieListe.anhaengen(902);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902});

        assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198));
        dieListe.anhaengen(921);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921});

        dieListe.anhaengen(22);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22});

        dieListe.anhaengen(146);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146});

        dieListe.anhaengen(23);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23});

        assertFalse("Fehler: Element 696 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(696));
        dieListe.anhaengen(551);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551});

        assertFalse("Fehler: Element 518 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(518));
        dieListe.anhaengen(792);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792});

        assertTrue("Fehler: Element 666 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(666));
        dieListe.anhaengen(79);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79});

        dieListe.anhaengen(658);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658});

        assertFalse("Fehler: Element 873 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(873));
        assertTrue("Fehler: Element 820 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(820));
        dieListe.anhaengen(389);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389});

        dieListe.anhaengen(799);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799});

        assertTrue("Fehler: Element 103 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(103));
        assertFalse("Fehler: Element 795 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(795));
        assertTrue("Fehler: Element 820 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(820));
        assertTrue("Fehler: Element 341 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(341));
        dieListe.anhaengen(627);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627});

        dieListe.anhaengen(807);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807});

        assertFalse("Fehler: Element 228 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(228));
        assertTrue("Fehler: Element 468 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(468));
        assertTrue("Fehler: Element 902 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(902));
        dieListe.anhaengen(289);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289});

        dieListe.anhaengen(771);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771});

        assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994));
        assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146));
        dieListe.anhaengen(733);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771, 733});

        dieListe.anhaengen(357);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771, 733, 357});

        dieListe.anhaengen(262);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771, 733, 357, 262});

        assertFalse("Fehler: Element 99 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(99));
        assertTrue("Fehler: Element 554 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(554));
        dieListe.anhaengen(121);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771, 733, 357, 262, 121});

        assertTrue("Fehler: Element 590 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(590));
        assertFalse("Fehler: Element 450 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(450));
        dieListe.anhaengen(663);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771, 733, 357, 262, 121, 663});

        assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714));
        dieListe.anhaengen(392);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771, 733, 357, 262, 121, 663, 392});

        assertTrue("Fehler: Element 162 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(162));
        dieListe.anhaengen(962);
        Tester.pruefeListenInhalt(dieListe, new int[]{622, 503, 940, 588, 575, 468, 283, 162, 103, 341, 590, 940, 389, 282, 666, 380, 659, 554, 820, 508, 435, 547, 825, 875, 683, 479, 828, 111, 686, 731, 183, 902, 921, 22, 146, 23, 551, 792, 79, 658, 389, 799, 627, 807, 289, 771, 733, 357, 262, 121, 663, 392, 962});

    }

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

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

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

        dieListe.anhaengen(542);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542});

        dieListe.anhaengen(697);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697});

        assertTrue("Fehler: Element 895 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(895));
        dieListe.anhaengen(717);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717});

        dieListe.anhaengen(793);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793});

        assertFalse("Fehler: Element 917 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(917));
        dieListe.anhaengen(800);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800});

        assertFalse("Fehler: Element 247 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(247));
        dieListe.anhaengen(328);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328});

        dieListe.anhaengen(20);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20});

        dieListe.anhaengen(678);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678});

        dieListe.anhaengen(313);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313});

        assertTrue("Fehler: Element 542 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(542));
        assertFalse("Fehler: Element 998 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(998));
        dieListe.anhaengen(581);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581});

        dieListe.anhaengen(567);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567});

        dieListe.anhaengen(51);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51});

        dieListe.anhaengen(639);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639});

        dieListe.anhaengen(778);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778});

        assertFalse("Fehler: Element 708 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(708));
        assertFalse("Fehler: Element 632 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(632));
        assertFalse("Fehler: Element 406 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(406));
        dieListe.anhaengen(141);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141});

        dieListe.anhaengen(565);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565});

        assertFalse("Fehler: Element 987 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(987));
        assertFalse("Fehler: Element 499 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(499));
        assertTrue("Fehler: Element 20 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(20));
        dieListe.anhaengen(884);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884});

        dieListe.anhaengen(643);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643});

        dieListe.anhaengen(702);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702});

        assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208));
        assertTrue("Fehler: Element 313 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(313));
        dieListe.anhaengen(785);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785});

        dieListe.anhaengen(581);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581});

        dieListe.anhaengen(941);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941});

        assertFalse("Fehler: Element 576 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(576));
        dieListe.anhaengen(201);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201});

        dieListe.anhaengen(478);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478});

        assertTrue("Fehler: Element 565 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(565));
        assertTrue("Fehler: Element 565 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(565));
        assertTrue("Fehler: Element 793 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(793));
        dieListe.anhaengen(571);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571});

        dieListe.anhaengen(772);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772});

        dieListe.anhaengen(2);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2});

        dieListe.anhaengen(256);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256});

        dieListe.anhaengen(368);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368});

        assertFalse("Fehler: Element 299 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(299));
        assertTrue("Fehler: Element 793 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(793));
        assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581));
        assertTrue("Fehler: Element 785 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(785));
        assertTrue("Fehler: Element 2 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(2));
        assertFalse("Fehler: Element 937 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(937));
        dieListe.anhaengen(444);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444});

        dieListe.anhaengen(556);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556});

        assertFalse("Fehler: Element 45 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(45));
        dieListe.anhaengen(181);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181});

        dieListe.anhaengen(877);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877});

        assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778));
        dieListe.anhaengen(646);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646});

        dieListe.anhaengen(188);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188});

        assertTrue("Fehler: Element 556 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(556));
        assertFalse("Fehler: Element 942 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(942));
        assertTrue("Fehler: Element 702 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(702));
        assertTrue("Fehler: Element 51 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(51));
        dieListe.anhaengen(153);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153});

        assertTrue("Fehler: Element 2 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(2));
        dieListe.anhaengen(115);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115});

        dieListe.anhaengen(987);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987});

        dieListe.anhaengen(533);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533});

        assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876));
        dieListe.anhaengen(369);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369});

        dieListe.anhaengen(774);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774});

        assertTrue("Fehler: Element 141 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(141));
        assertFalse("Fehler: Element 896 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(896));
        dieListe.anhaengen(733);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733});

        assertTrue("Fehler: Element 20 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(20));
        dieListe.anhaengen(137);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137});

        assertFalse("Fehler: Element 916 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(916));
        dieListe.anhaengen(974);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137, 974});

        dieListe.anhaengen(961);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137, 974, 961});

        assertTrue("Fehler: Element 137 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(137));
        dieListe.anhaengen(944);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137, 974, 961, 944});

        dieListe.anhaengen(870);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137, 974, 961, 944, 870});

        assertFalse("Fehler: Element 384 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(384));
        dieListe.anhaengen(86);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137, 974, 961, 944, 870, 86});

        assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477));
        assertTrue("Fehler: Element 671 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(671));
        assertFalse("Fehler: Element 662 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(662));
        assertFalse("Fehler: Element 64 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(64));
        dieListe.anhaengen(359);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137, 974, 961, 944, 870, 86, 359});

        assertFalse("Fehler: Element 755 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(755));
        dieListe.anhaengen(872);
        Tester.pruefeListenInhalt(dieListe, new int[]{671, 895, 49, 542, 697, 717, 793, 800, 328, 20, 678, 313, 581, 567, 51, 639, 778, 141, 565, 884, 643, 702, 785, 581, 941, 201, 478, 571, 772, 2, 256, 368, 444, 556, 181, 877, 646, 188, 153, 115, 987, 533, 369, 774, 733, 137, 974, 961, 944, 870, 86, 359, 872});

        assertTrue("Fehler: Element 201 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(201));
        assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140));
        assertFalse("Fehler: Element 940 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(940));
    }
}
